@stevenvo780/st-lang 0.4.0 → 0.5.0

package/dist/profiles/deontic/standard.js

@@ -0,0 +1,74 @@
+"use strict";
+// ============================================================
+// ST Deontic Standard — KD sobre BaseTableauProfile
+// ============================================================
+// O(φ) = [](φ)  — obligación
+// P(φ) = <>(φ)  — permisión
+// F(φ) = [](!φ) — prohibición
+// Axioma D: O(φ) → P(φ) — serialidad
+// ============================================================
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeonticStandard = void 0;
+const propositional_1 = require("../classical/propositional");
+const base_profile_1 = require("../shared/base-profile");
+const tableau_engine_1 = require("../shared/tableau-engine");
+class DeonticStandard extends base_profile_1.BaseTableauProfile {
+    name = 'deontic.standard';
+    description = 'Lógica deóntica estándar (KD) — obligación (O/[]), permisión (P/<>), prohibición (F/[]!)';
+    frameRules = tableau_engine_1.FRAME_KD;
+    formatFormula(f) {
+        return deonticToString(f);
+    }
+    explainSystem() {
+        return [
+            'Operadores deónticos:',
+            '  O(φ) = [](φ)  — "Es obligatorio que φ"',
+            '  P(φ) = <>(φ)  — "Está permitido que φ"',
+            '  F(φ) = [](!φ) — "Está prohibido que φ"',
+            '',
+            'Sistema: KD (K + axioma D)',
+            '  Axioma K: O(φ→ψ) → (O(φ)→O(ψ))',
+            '  Axioma D: O(φ) → P(φ) — "lo obligatorio es permisible"',
+            '  Serialidad: todo mundo tiene al menos un mundo accesible',
+        ].join('\n');
+    }
+}
+exports.DeonticStandard = DeonticStandard;
+function deonticToString(f) {
+    switch (f.kind) {
+        case 'modal_necessity': {
+            const inner = (f.args || [])[0];
+            if (!inner)
+                return 'O(?)';
+            if (inner.kind === 'not' && inner.args?.[0]) {
+                return `F(${deonticToString(inner.args[0])})`;
+            }
+            return `O(${deonticToString(inner)})`;
+        }
+        case 'modal_possibility': {
+            const inner = (f.args || [])[0];
+            return inner ? `P(${deonticToString(inner)})` : 'P(?)';
+        }
+        case 'atom':
+            return f.name || '?';
+        case 'not': {
+            const inner = (f.args || [])[0];
+            if (!inner)
+                return '¬?';
+            if (inner.kind === 'atom')
+                return `¬${deonticToString(inner)}`;
+            return `¬(${deonticToString(inner)})`;
+        }
+        case 'and':
+            return `(${deonticToString((f.args || [])[0])} ∧ ${deonticToString((f.args || [])[1])})`;
+        case 'or':
+            return `(${deonticToString((f.args || [])[0])} ∨ ${deonticToString((f.args || [])[1])})`;
+        case 'implies':
+            return `(${deonticToString((f.args || [])[0])} → ${deonticToString((f.args || [])[1])})`;
+        case 'biconditional':
+            return `(${deonticToString((f.args || [])[0])} ↔ ${deonticToString((f.args || [])[1])})`;
+        default:
+            return (0, propositional_1.formulaToString)(f);
+    }
+}
+//# sourceMappingURL=standard.js.map

package/dist/profiles/deontic/standard.js.map

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

package/dist/profiles/epistemic/s5.d.ts

@@ -0,0 +1,10 @@
+import { Formula } from '../../types';
+import { BaseTableauProfile } from '../shared/base-profile';
+export declare class EpistemicS5 extends BaseTableauProfile {
+    name: string;
+    description: string;
+    frameRules: import("../shared/tableau-engine").FrameRules;
+    formatFormula(f: Formula): string;
+    explainSystem(): string;
+}
+//# sourceMappingURL=s5.d.ts.map

package/dist/profiles/epistemic/s5.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"s5.d.ts","sourceRoot":"","sources":["../../../src/profiles/epistemic/s5.ts"],"names":[],"mappings":"AAQA,OAAO,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAEtC,OAAO,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AAG5D,qBAAa,WAAY,SAAQ,kBAAkB;IACjD,IAAI,SAAkB;IACtB,WAAW,SAAgF;IAC3F,UAAU,gDAAY;IAEtB,aAAa,CAAC,CAAC,EAAE,OAAO,GAAG,MAAM;IAIjC,aAAa,IAAI,MAAM;CAexB"}

package/dist/profiles/epistemic/s5.js

@@ -0,0 +1,70 @@
+"use strict";
+// ============================================================
+// ST Epistemic S5 — S5 sobre BaseTableauProfile
+// ============================================================
+// K(φ) = [](φ) — conocimiento
+// B(φ) = <>(φ) — creencia
+// S5 = K + T + 4 + B (relación de accesibilidad universal)
+// ============================================================
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EpistemicS5 = void 0;
+const propositional_1 = require("../classical/propositional");
+const base_profile_1 = require("../shared/base-profile");
+const tableau_engine_1 = require("../shared/tableau-engine");
+class EpistemicS5 extends base_profile_1.BaseTableauProfile {
+    name = 'epistemic.s5';
+    description = 'Lógica epistémica S5 — conocimiento (K/[]), creencia (B/<>), introspección';
+    frameRules = tableau_engine_1.FRAME_S5;
+    formatFormula(f) {
+        return epistemicToString(f);
+    }
+    explainSystem() {
+        return [
+            'Operadores epistémicos:',
+            '  K(φ) = [](φ) — "el agente sabe que φ"',
+            '  B(φ) = <>(φ) — "el agente cree que φ"',
+            '',
+            'Sistema: S5 (K + T + 4 + B)',
+            '  Axioma K:  K(φ→ψ) → (Kφ→Kψ)  — distribución',
+            '  Axioma T:  Kφ → φ             — veridicidad (lo sabido es verdad)',
+            '  Axioma 4:  Kφ → KKφ           — introspección positiva',
+            '  Axioma B:  φ → K¬K¬φ          — introspección negativa',
+            '',
+            '  Relación de accesibilidad: universal (equivalencia)',
+        ].join('\n');
+    }
+}
+exports.EpistemicS5 = EpistemicS5;
+function epistemicToString(f) {
+    switch (f.kind) {
+        case 'modal_necessity': {
+            const inner = (f.args || [])[0];
+            return inner ? `K(${epistemicToString(inner)})` : 'K(?)';
+        }
+        case 'modal_possibility': {
+            const inner = (f.args || [])[0];
+            return inner ? `B(${epistemicToString(inner)})` : 'B(?)';
+        }
+        case 'atom':
+            return f.name || '?';
+        case 'not': {
+            const inner = (f.args || [])[0];
+            if (!inner)
+                return '¬?';
+            if (inner.kind === 'atom')
+                return `¬${epistemicToString(inner)}`;
+            return `¬(${epistemicToString(inner)})`;
+        }
+        case 'and':
+            return `(${epistemicToString((f.args || [])[0])} ∧ ${epistemicToString((f.args || [])[1])})`;
+        case 'or':
+            return `(${epistemicToString((f.args || [])[0])} ∨ ${epistemicToString((f.args || [])[1])})`;
+        case 'implies':
+            return `(${epistemicToString((f.args || [])[0])} → ${epistemicToString((f.args || [])[1])})`;
+        case 'biconditional':
+            return `(${epistemicToString((f.args || [])[0])} ↔ ${epistemicToString((f.args || [])[1])})`;
+        default:
+            return (0, propositional_1.formulaToString)(f);
+    }
+}
+//# sourceMappingURL=s5.js.map

package/dist/profiles/epistemic/s5.js.map

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

package/dist/profiles/index.d.ts

@@ -0,0 +1,13 @@
+import { ClassicalPropositional } from './classical/propositional';
+import { ClassicalFirstOrder } from './classical/first-order';
+import { ModalK } from './modal/k';
+import { ParaconsistentBelnap } from './paraconsistent/belnap';
+import { DeonticStandard } from './deontic/standard';
+import { EpistemicS5 } from './epistemic/s5';
+import { AristotelianSyllogistic } from './aristotelian/syllogistic';
+import { IntuitionisticPropositional } from './intuitionistic/propositional';
+import { TemporalLTL } from './temporal/ltl';
+import { ProbabilisticBasic } from './probabilistic/basic';
+export { ClassicalPropositional, ClassicalFirstOrder, ModalK, ParaconsistentBelnap, DeonticStandard, EpistemicS5, AristotelianSyllogistic, IntuitionisticPropositional, TemporalLTL, ProbabilisticBasic, };
+export { registry, ProfileRegistry } from './interface';
+//# sourceMappingURL=index.d.ts.map

package/dist/profiles/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/profiles/index.ts"],"names":[],"mappings":"AAcA,OAAO,EAAE,sBAAsB,EAAE,MAAM,2BAA2B,CAAC;AACnE,OAAO,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;AAC9D,OAAO,EAAE,MAAM,EAAE,MAAM,WAAW,CAAC;AACnC,OAAO,EAAE,oBAAoB,EAAE,MAAM,yBAAyB,CAAC;AAC/D,OAAO,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AACrD,OAAO,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAC7C,OAAO,EAAE,uBAAuB,EAAE,MAAM,4BAA4B,CAAC;AACrE,OAAO,EAAE,2BAA2B,EAAE,MAAM,gCAAgC,CAAC;AAC7E,OAAO,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAC7C,OAAO,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AAwB3D,OAAO,EACL,sBAAsB,EACtB,mBAAmB,EACnB,MAAM,EACN,oBAAoB,EACpB,eAAe,EACf,WAAW,EACX,uBAAuB,EACvB,2BAA2B,EAC3B,WAAW,EACX,kBAAkB,GACnB,CAAC;AACF,OAAO,EAAE,QAAQ,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC"}

package/dist/profiles/index.js

@@ -0,0 +1,58 @@
+"use strict";
+// ============================================================
+// ST Profiles — Barrel de registro automático
+// ============================================================
+// Este archivo importa y registra todos los perfiles built-in.
+// Para añadir un nuevo perfil, simplemente impórtalo aquí y
+// llama a registry.register(new MiPerfil()).
+//
+// Los perfiles externos pueden usar registerProfile() de la API
+// pública sin modificar este archivo.
+// ============================================================
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProfileRegistry = exports.registry = exports.ProbabilisticBasic = exports.TemporalLTL = exports.IntuitionisticPropositional = exports.AristotelianSyllogistic = exports.EpistemicS5 = exports.DeonticStandard = exports.ParaconsistentBelnap = exports.ModalK = exports.ClassicalFirstOrder = exports.ClassicalPropositional = void 0;
+const interface_1 = require("./interface");
+// ── Built-in profiles ─────────────────────────────────────────
+const propositional_1 = require("./classical/propositional");
+Object.defineProperty(exports, "ClassicalPropositional", { enumerable: true, get: function () { return propositional_1.ClassicalPropositional; } });
+const first_order_1 = require("./classical/first-order");
+Object.defineProperty(exports, "ClassicalFirstOrder", { enumerable: true, get: function () { return first_order_1.ClassicalFirstOrder; } });
+const k_1 = require("./modal/k");
+Object.defineProperty(exports, "ModalK", { enumerable: true, get: function () { return k_1.ModalK; } });
+const belnap_1 = require("./paraconsistent/belnap");
+Object.defineProperty(exports, "ParaconsistentBelnap", { enumerable: true, get: function () { return belnap_1.ParaconsistentBelnap; } });
+const standard_1 = require("./deontic/standard");
+Object.defineProperty(exports, "DeonticStandard", { enumerable: true, get: function () { return standard_1.DeonticStandard; } });
+const s5_1 = require("./epistemic/s5");
+Object.defineProperty(exports, "EpistemicS5", { enumerable: true, get: function () { return s5_1.EpistemicS5; } });
+const syllogistic_1 = require("./aristotelian/syllogistic");
+Object.defineProperty(exports, "AristotelianSyllogistic", { enumerable: true, get: function () { return syllogistic_1.AristotelianSyllogistic; } });
+const propositional_2 = require("./intuitionistic/propositional");
+Object.defineProperty(exports, "IntuitionisticPropositional", { enumerable: true, get: function () { return propositional_2.IntuitionisticPropositional; } });
+const ltl_1 = require("./temporal/ltl");
+Object.defineProperty(exports, "TemporalLTL", { enumerable: true, get: function () { return ltl_1.TemporalLTL; } });
+const basic_1 = require("./probabilistic/basic");
+Object.defineProperty(exports, "ProbabilisticBasic", { enumerable: true, get: function () { return basic_1.ProbabilisticBasic; } });
+// Registro idempotente
+const builtins = [
+    propositional_1.ClassicalPropositional,
+    first_order_1.ClassicalFirstOrder,
+    k_1.ModalK,
+    belnap_1.ParaconsistentBelnap,
+    standard_1.DeonticStandard,
+    s5_1.EpistemicS5,
+    syllogistic_1.AristotelianSyllogistic,
+    propositional_2.IntuitionisticPropositional,
+    ltl_1.TemporalLTL,
+    basic_1.ProbabilisticBasic,
+];
+for (const Profile of builtins) {
+    const instance = new Profile();
+    if (!interface_1.registry.has(instance.name)) {
+        interface_1.registry.register(instance);
+    }
+}
+var interface_2 = require("./interface");
+Object.defineProperty(exports, "registry", { enumerable: true, get: function () { return interface_2.registry; } });
+Object.defineProperty(exports, "ProfileRegistry", { enumerable: true, get: function () { return interface_2.ProfileRegistry; } });
+//# sourceMappingURL=index.js.map

package/dist/profiles/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/profiles/index.ts"],"names":[],"mappings":";AAAA,+DAA+D;AAC/D,8CAA8C;AAC9C,+DAA+D;AAC/D,+DAA+D;AAC/D,4DAA4D;AAC5D,6CAA6C;AAC7C,EAAE;AACF,gEAAgE;AAChE,sCAAsC;AACtC,+DAA+D;;;AAE/D,2CAAuC;AAEvC,iEAAiE;AACjE,6DAAmE;AAkCjE,uGAlCO,sCAAsB,OAkCP;AAjCxB,yDAA8D;AAkC5D,oGAlCO,iCAAmB,OAkCP;AAjCrB,iCAAmC;AAkCjC,uFAlCO,UAAM,OAkCP;AAjCR,oDAA+D;AAkC7D,qGAlCO,6BAAoB,OAkCP;AAjCtB,iDAAqD;AAkCnD,gGAlCO,0BAAe,OAkCP;AAjCjB,uCAA6C;AAkC3C,4FAlCO,gBAAW,OAkCP;AAjCb,4DAAqE;AAkCnE,wGAlCO,qCAAuB,OAkCP;AAjCzB,kEAA6E;AAkC3E,4GAlCO,2CAA2B,OAkCP;AAjC7B,wCAA6C;AAkC3C,4FAlCO,iBAAW,OAkCP;AAjCb,iDAA2D;AAkCzD,mGAlCO,0BAAkB,OAkCP;AAhCpB,uBAAuB;AACvB,MAAM,QAAQ,GAAG;IACf,sCAAsB;IACtB,iCAAmB;IACnB,UAAM;IACN,6BAAoB;IACpB,0BAAe;IACf,gBAAW;IACX,qCAAuB;IACvB,2CAA2B;IAC3B,iBAAW;IACX,0BAAkB;CACnB,CAAC;AAEF,KAAK,MAAM,OAAO,IAAI,QAAQ,EAAE,CAAC;IAC/B,MAAM,QAAQ,GAAG,IAAI,OAAO,EAAE,CAAC;IAC/B,IAAI,CAAC,oBAAQ,CAAC,GAAG,CAAC,QAAQ,CAAC,IAAI,CAAC,EAAE,CAAC;QACjC,oBAAQ,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAC;IAC9B,CAAC;AACH,CAAC;AAeD,yCAAwD;AAA/C,qGAAA,QAAQ,OAAA;AAAE,4GAAA,eAAe,OAAA"}

package/dist/profiles/intuitionistic/propositional.d.ts

@@ -0,0 +1,14 @@
+import { Formula } from '../../types';
+import type { RunResult, Theory, Diagnostic, LogicProfile } from '../../types';
+export declare class IntuitionisticPropositional implements LogicProfile {
+    name: string;
+    description: string;
+    checkWellFormed(formula: Formula): Diagnostic[];
+    checkValid(formula: Formula): RunResult;
+    checkSatisfiable(formula: Formula): RunResult;
+    prove(goal: Formula, theory: Theory): RunResult;
+    derive(goal: Formula, premises: string[], theory: Theory): RunResult;
+    countermodel(formula: Formula): RunResult;
+    explain(formula: Formula): RunResult;
+}
+//# sourceMappingURL=propositional.d.ts.map

package/dist/profiles/intuitionistic/propositional.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"propositional.d.ts","sourceRoot":"","sources":["../../../src/profiles/intuitionistic/propositional.ts"],"names":[],"mappings":"AAgBA,OAAO,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAEtC,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AA6P/E,qBAAa,2BAA4B,YAAW,YAAY;IAC9D,IAAI,SAAkC;IACtC,WAAW,SACmF;IAE9F,eAAe,CAAC,OAAO,EAAE,OAAO,GAAG,UAAU,EAAE;IAkB/C,UAAU,CAAC,OAAO,EAAE,OAAO,GAAG,SAAS;IAavC,gBAAgB,CAAC,OAAO,EAAE,OAAO,GAAG,SAAS;IAa7C,KAAK,CAAC,IAAI,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,GAAG,SAAS;IAQ/C,MAAM,CAAC,IAAI,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,EAAE,EAAE,MAAM,EAAE,MAAM,GAAG,SAAS;IAoBpE,YAAY,CAAC,OAAO,EAAE,OAAO,GAAG,SAAS;IAwBzC,OAAO,CAAC,OAAO,EAAE,OAAO,GAAG,SAAS;CA6BrC"}

package/dist/profiles/intuitionistic/propositional.js

@@ -0,0 +1,377 @@
+"use strict";
+// ============================================================
+// ST Intuitionistic Propositional — Kripke directo
+// ============================================================
+// Lógica intuicionista (IPC): sin ley del tercero excluido,
+// sin doble negación eliminación.
+//
+// Implementación: enumeración exhaustiva de modelos Kripke
+// finitos (preórdenes con persistencia de átomos).
+// Para fórmulas proposicionales con n átomos, generamos todos
+// los preórdenes de tamaño ≤ k y todas las valuaciones
+// persistentes, verificando si la fórmula se fuerza en la raíz.
+//
+// Corrección: IPC es completa respecto a frames finitos
+// (teorema de completitud de Kripke).
+// ============================================================
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IntuitionisticPropositional = void 0;
+const propositional_1 = require("../classical/propositional");
+// ── Recolectar átomos ───────────────────────────────────────
+function collectAtoms(f) {
+    const atoms = new Set();
+    const walk = (node) => {
+        if (node.kind === 'atom' && node.name)
+            atoms.add(node.name);
+        node.args?.forEach(walk);
+    };
+    walk(f);
+    return atoms;
+}
+// ── Forzar (forcing) intuicionista ──────────────────────────
+function forces(model, w, f) {
+    switch (f.kind) {
+        case 'atom':
+            return model.val.get(w)?.has(f.name || '') || false;
+        case 'not': {
+            // ¬φ se fuerza en w sii NO existe v ≥ w tal que v ⊩ φ
+            const inner = (f.args || [])[0];
+            if (!inner)
+                return true;
+            for (const v of reachable(model, w)) {
+                if (forces(model, v, inner))
+                    return false;
+            }
+            return true;
+        }
+        case 'and': {
+            const args = f.args || [];
+            return args.every((a) => forces(model, w, a));
+        }
+        case 'or': {
+            const args = f.args || [];
+            return args.some((a) => forces(model, w, a));
+        }
+        case 'implies': {
+            // φ→ψ se fuerza en w sii para todo v ≥ w, si v ⊩ φ entonces v ⊩ ψ
+            const args = f.args || [];
+            if (args.length < 2)
+                return true;
+            for (const v of reachable(model, w)) {
+                if (forces(model, v, args[0]) && !forces(model, v, args[1]))
+                    return false;
+            }
+            return true;
+        }
+        case 'biconditional': {
+            const args = f.args || [];
+            if (args.length < 2)
+                return true;
+            const impl1 = { kind: 'implies', args: [args[0], args[1]] };
+            const impl2 = { kind: 'implies', args: [args[1], args[0]] };
+            return forces(model, w, impl1) && forces(model, w, impl2);
+        }
+        // Modal: interpretar □ como universal en accesibles, ◇ como existencial
+        case 'modal_necessity': {
+            const inner = (f.args || [])[0];
+            if (!inner)
+                return true;
+            for (const v of reachable(model, w)) {
+                if (!forces(model, v, inner))
+                    return false;
+            }
+            return true;
+        }
+        case 'modal_possibility': {
+            const inner = (f.args || [])[0];
+            if (!inner)
+                return false;
+            for (const v of reachable(model, w)) {
+                if (forces(model, v, inner))
+                    return true;
+            }
+            return false;
+        }
+        default:
+            return false;
+    }
+}
+/** Cierre transitivo-reflexivo desde w */
+function reachable(model, w) {
+    const visited = new Set();
+    const queue = [w];
+    while (queue.length > 0) {
+        const current = queue.shift();
+        if (visited.has(current))
+            continue;
+        visited.add(current);
+        for (const next of model.access.get(current) || []) {
+            queue.push(next);
+        }
+    }
+    return Array.from(visited);
+}
+// ── Generador de modelos Kripke finitos ─────────────────────
+/**
+ * Genera todos los preórdenes (reflexivos + transitivos)
+ * sobre {0, ..., n-1} y todas las valuaciones persistentes
+ * de los átomos dados.
+ *
+ * Para IPC proposicional con pocos átomos, 3 mundos son
+ * suficientes para refutar cualquier no-teorema.
+ */
+function* generateModels(atoms, maxWorlds) {
+    const n = Math.min(maxWorlds, 4); // Limitar a 4 mundos máx
+    for (let size = 1; size <= n; size++) {
+        const worlds = Array.from({ length: size }, (_, i) => i);
+        // Generar todos los subconjuntos de aristas (sin incluir reflexivas, que siempre van)
+        const pairs = [];
+        for (let i = 0; i < size; i++) {
+            for (let j = 0; j < size; j++) {
+                if (i !== j)
+                    pairs.push([i, j]);
+            }
+        }
+        const edgeCombinations = 1 << pairs.length;
+        for (let edgeMask = 0; edgeMask < edgeCombinations; edgeMask++) {
+            // Construir relación de accesibilidad
+            const access = new Map();
+            for (const w of worlds)
+                access.set(w, new Set([w])); // Reflexividad
+            for (let b = 0; b < pairs.length; b++) {
+                if (edgeMask & (1 << b)) {
+                    access.get(pairs[b][0]).add(pairs[b][1]);
+                }
+            }
+            // Cerrar transitivamente
+            transitiveClosure(access, worlds);
+            // Generar todas las valuaciones persistentes
+            yield* generatePersistentValuations(worlds, access, atoms);
+        }
+    }
+}
+function transitiveClosure(access, worlds) {
+    let changed = true;
+    while (changed) {
+        changed = false;
+        for (const w of worlds) {
+            const acc = access.get(w);
+            const toAdd = [];
+            for (const v of acc) {
+                for (const u of access.get(v) || []) {
+                    if (!acc.has(u))
+                        toAdd.push(u);
+                }
+            }
+            for (const u of toAdd) {
+                acc.add(u);
+                changed = true;
+            }
+        }
+    }
+}
+function* generatePersistentValuations(worlds, access, atoms) {
+    const upwardSets = computeUpwardSets(worlds, access);
+    const atomCount = atoms.length;
+    // Cada átomo elige uno de los upward-closed sets
+    const total = Math.pow(upwardSets.length, atomCount);
+    for (let i = 0; i < total; i++) {
+        const val = new Map();
+        for (const w of worlds)
+            val.set(w, new Set());
+        let idx = i;
+        for (let a = 0; a < atomCount; a++) {
+            const setIdx = idx % upwardSets.length;
+            idx = Math.floor(idx / upwardSets.length);
+            const truthWorlds = upwardSets[setIdx];
+            for (const w of truthWorlds) {
+                val.get(w).add(atoms[a]);
+            }
+        }
+        yield { worlds, access, val };
+    }
+}
+function computeUpwardSets(worlds, access) {
+    // Un conjunto S es upward-closed si w∈S y wRv implica v∈S
+    const n = worlds.length;
+    const result = [];
+    const total = 1 << n;
+    for (let mask = 0; mask < total; mask++) {
+        const set = worlds.filter((_, i) => mask & (1 << i));
+        let upward = true;
+        for (const w of set) {
+            for (const v of access.get(w) || []) {
+                if (!(mask & (1 << v))) {
+                    upward = false;
+                    break;
+                }
+            }
+            if (!upward)
+                break;
+        }
+        if (upward)
+            result.push(set);
+    }
+    return result;
+}
+// ── Verificación de validez ─────────────────────────────────
+/** ¿Es φ válida en IPC? (forzada en la raíz de todo modelo Kripke finito) */
+function isIPCValid(formula) {
+    const atoms = Array.from(collectAtoms(formula));
+    const maxWorlds = atoms.length <= 2 ? 4 : 3;
+    for (const model of generateModels(atoms, maxWorlds)) {
+        if (!forces(model, 0, formula))
+            return false;
+    }
+    return true;
+}
+/** ¿Es φ satisfacible en IPC? */
+function isIPCSatisfiable(formula) {
+    const atoms = Array.from(collectAtoms(formula));
+    const maxWorlds = atoms.length <= 2 ? 4 : 3;
+    for (const model of generateModels(atoms, maxWorlds)) {
+        if (forces(model, 0, formula))
+            return true;
+    }
+    return false;
+}
+// ── Profile ─────────────────────────────────────────────────
+class IntuitionisticPropositional {
+    name = 'intuitionistic.propositional';
+    description = 'Lógica intuicionista proposicional — sin tercero excluido, sin doble negación eliminación';
+    checkWellFormed(formula) {
+        const diags = [];
+        const walk = (f) => {
+            if (f.kind === 'atom' && !f.name) {
+                diags.push({ severity: 'error', message: 'Átomo sin nombre' });
+            }
+            if (f.kind === 'modal_necessity' || f.kind === 'modal_possibility') {
+                diags.push({
+                    severity: 'warning',
+                    message: 'Los operadores modales □/◇ no forman parte de la lógica intuicionista',
+                });
+            }
+            f.args?.forEach(walk);
+        };
+        walk(formula);
+        return diags;
+    }
+    checkValid(formula) {
+        const valid = isIPCValid(formula);
+        const fStr = (0, propositional_1.formulaToString)(formula);
+        return {
+            status: valid ? 'valid' : 'invalid',
+            output: valid
+                ? `${fStr} es VÁLIDA intuicionistamente`
+                : `${fStr} NO es válida intuicionistamente`,
+            diagnostics: [],
+            formula,
+        };
+    }
+    checkSatisfiable(formula) {
+        const sat = isIPCSatisfiable(formula);
+        const fStr = (0, propositional_1.formulaToString)(formula);
+        return {
+            status: sat ? 'satisfiable' : 'unsatisfiable',
+            output: sat
+                ? `${fStr} es SATISFACIBLE intuicionistamente`
+                : `${fStr} es INSATISFACIBLE intuicionistamente`,
+            diagnostics: [],
+            formula,
+        };
+    }
+    prove(goal, theory) {
+        const axioms = Array.from(theory.axioms.values());
+        if (axioms.length === 0)
+            return this.checkValid(goal);
+        const conj = axioms.reduce((a, b) => ({ kind: 'and', args: [a, b] }));
+        const impl = { kind: 'implies', args: [conj, goal] };
+        return this.checkValid(impl);
+    }
+    derive(goal, premises, theory) {
+        const fs = [];
+        for (const n of premises) {
+            const f = theory.axioms.get(n) || theory.theorems.get(n);
+            if (!f) {
+                return {
+                    status: 'error',
+                    output: `Premisa no encontrada: ${n}`,
+                    diagnostics: [{ severity: 'error', message: `'${n}' no definida` }],
+                    formula: goal,
+                };
+            }
+            fs.push(f);
+        }
+        if (fs.length === 0)
+            return this.checkValid(goal);
+        const conj = fs.reduce((a, b) => ({ kind: 'and', args: [a, b] }));
+        const impl = { kind: 'implies', args: [conj, goal] };
+        return this.checkValid(impl);
+    }
+    countermodel(formula) {
+        const atoms = Array.from(collectAtoms(formula));
+        const maxWorlds = atoms.length <= 2 ? 4 : 3;
+        const fStr = (0, propositional_1.formulaToString)(formula);
+        for (const model of generateModels(atoms, maxWorlds)) {
+            if (!forces(model, 0, formula)) {
+                const desc = describeModel(model);
+                return {
+                    status: 'invalid',
+                    output: `Contramodelo intuicionista para ${fStr}:\n${desc}`,
+                    diagnostics: [],
+                    formula,
+                };
+            }
+        }
+        return {
+            status: 'valid',
+            output: `No existe contramodelo — ${fStr} es válida intuicionistamente`,
+            diagnostics: [],
+            formula,
+        };
+    }
+    explain(formula) {
+        const fStr = (0, propositional_1.formulaToString)(formula);
+        const valid = isIPCValid(formula);
+        let explanation = `Fórmula: ${fStr}\n\n`;
+        explanation += [
+            'Sistema: Lógica Intuicionista Proposicional (IPC)',
+            '',
+            'Rechazos clave vs. clásica:',
+            '  ✗ P ∨ ¬P          — Tercero excluido (LEM)',
+            '  ✗ ¬¬P → P         — Doble negación eliminación (DNE)',
+            '  ✗ ((P→Q)→P) → P   — Ley de Peirce',
+            '',
+            'Aceptados en IPC:',
+            '  ✓ P → ¬¬P         — Doble negación introducción',
+            '  ✓ (P→Q) → (¬Q→¬P) — Contraposición',
+            '  ✓ (P ∧ ¬P) → Q    — Ex falso quodlibet',
+            '',
+            'Semántica: Kripke con preórdenes (reflexivo + transitivo)',
+            '  Los átomos son persistentes (monótonos)',
+            '  Implementación: enumeración de modelos finitos',
+        ].join('\n');
+        explanation += `\n\nEstatus: ${valid ? 'VÁLIDA' : 'NO válida'} intuicionistamente`;
+        return {
+            status: valid ? 'valid' : 'invalid',
+            output: explanation,
+            diagnostics: [],
+            formula,
+        };
+    }
+}
+exports.IntuitionisticPropositional = IntuitionisticPropositional;
+// ── Utilidades ──────────────────────────────────────────────
+function describeModel(model) {
+    const lines = [];
+    lines.push(`Mundos: {${model.worlds.join(', ')}}`);
+    for (const w of model.worlds) {
+        const acc = Array.from(model.access.get(w) || []).filter((v) => v !== w);
+        if (acc.length > 0)
+            lines.push(`  ${w} → {${acc.join(', ')}}`);
+        const atoms = Array.from(model.val.get(w) || []);
+        lines.push(`  V(${w}) = {${atoms.join(', ')}}`);
+    }
+    return lines.join('\n');
+}
+//# sourceMappingURL=propositional.js.map