@stevenvo780/st-lang 4.1.0 → 4.3.0

package/dist/profiles/substructural/types.d.ts

@@ -0,0 +1,72 @@
+/**
+ * Formulas del lenguaje lineal/afin. Los atomos son neutrales y se
+ * comparan por nombre.
+ */
+export type LinearFormula = {
+    kind: 'atom';
+    name: string;
+} | {
+    kind: 'one';
+} | {
+    kind: 'tensor';
+    left: LinearFormula;
+    right: LinearFormula;
+} | {
+    kind: 'lollipop';
+    left: LinearFormula;
+    right: LinearFormula;
+} | {
+    kind: 'with';
+    left: LinearFormula;
+    right: LinearFormula;
+} | {
+    kind: 'plus';
+    left: LinearFormula;
+    right: LinearFormula;
+} | {
+    kind: 'bang';
+    arg: LinearFormula;
+} | {
+    kind: 'whynot';
+    arg: LinearFormula;
+};
+/**
+ * Reglas del calculo (intuicionistico) de secuentes que usamos.
+ *
+ * El sistema implementado es un calculo de secuentes ILL (Intuitionistic
+ * Linear Logic) restringido a un unico sucedente (Γ ⊢ A). Suficiente
+ * para los enunciados pedidos en el bench: A ⊸ A, conmutatividad,
+ * weakening solo en afin, contraction solo via bang, etc.
+ *
+ * Notas:
+ *   - `weakening` y `contraction` aparecen como reglas estructurales
+ *     explicitas; en linear puro estan deshabilitadas. En afin,
+ *     `weakening` esta habilitada (no asi `contraction`). En ambos,
+ *     `!` da contraction/weakening "locales" sobre el sub-recurso.
+ *   - `oneR` cierra el secuente ⊢ 1; `oneL` permite eliminar 1 a
+ *     izquierda.
+ */
+export type SequentRule = 'axiom' | 'cut' | 'oneR' | 'oneL' | 'tensorR' | 'tensorL' | 'lollipopR' | 'lollipopL' | 'withR' | 'withL1' | 'withL2' | 'plusR1' | 'plusR2' | 'plusL' | 'bangR' | 'bangL' | 'derelictionL' | 'weakening' | 'contraction';
+/**
+ * Secuente intuicionistico Γ ⊢ Δ. En el fragmento que probamos,
+ * `right` es de longitud 1 (un solo sucedente); se permite array
+ * para preservar simetria con G3 y futuras extensiones a Linear Logic
+ * clasica con multiples sucedentes.
+ */
+export interface LinearSequent {
+    left: LinearFormula[];
+    right: LinearFormula[];
+}
+export interface LinearProof {
+    conclusion: LinearSequent;
+    rule: SequentRule;
+    premises: LinearProof[];
+}
+/**
+ * Modo de prueba que controla las reglas estructurales.
+ *
+ *   - 'linear': ni contraction ni weakening (excepto via `!`).
+ *   - 'affine': weakening si, contraction no (excepto via `!`).
+ */
+export type SubstructuralMode = 'linear' | 'affine';
+//# sourceMappingURL=types.d.ts.map

package/dist/profiles/substructural/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/profiles/substructural/types.ts"],"names":[],"mappings":"AAyBA;;;GAGG;AACH,MAAM,MAAM,aAAa,GACrB;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GAC9B;IAAE,IAAI,EAAE,KAAK,CAAA;CAAE,GACf;IAAE,IAAI,EAAE,QAAQ,CAAC;IAAC,IAAI,EAAE,aAAa,CAAC;IAAC,KAAK,EAAE,aAAa,CAAA;CAAE,GAC7D;IAAE,IAAI,EAAE,UAAU,CAAC;IAAC,IAAI,EAAE,aAAa,CAAC;IAAC,KAAK,EAAE,aAAa,CAAA;CAAE,GAC/D;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,aAAa,CAAC;IAAC,KAAK,EAAE,aAAa,CAAA;CAAE,GAC3D;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,aAAa,CAAC;IAAC,KAAK,EAAE,aAAa,CAAA;CAAE,GAC3D;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,aAAa,CAAA;CAAE,GACpC;IAAE,IAAI,EAAE,QAAQ,CAAC;IAAC,GAAG,EAAE,aAAa,CAAA;CAAE,CAAC;AAE3C;;;;;;;;;;;;;;;GAeG;AACH,MAAM,MAAM,WAAW,GACnB,OAAO,GACP,KAAK,GACL,MAAM,GACN,MAAM,GACN,SAAS,GACT,SAAS,GACT,WAAW,GACX,WAAW,GACX,OAAO,GACP,QAAQ,GACR,QAAQ,GACR,QAAQ,GACR,QAAQ,GACR,OAAO,GACP,OAAO,GACP,OAAO,GACP,cAAc,GACd,WAAW,GACX,aAAa,CAAC;AAElB;;;;;GAKG;AACH,MAAM,WAAW,aAAa;IAC5B,IAAI,EAAE,aAAa,EAAE,CAAC;IACtB,KAAK,EAAE,aAAa,EAAE,CAAC;CACxB;AAED,MAAM,WAAW,WAAW;IAC1B,UAAU,EAAE,aAAa,CAAC;IAC1B,IAAI,EAAE,WAAW,CAAC;IAClB,QAAQ,EAAE,WAAW,EAAE,CAAC;CACzB;AAED;;;;;GAKG;AACH,MAAM,MAAM,iBAAiB,GAAG,QAAQ,GAAG,QAAQ,CAAC"}

package/dist/profiles/substructural/types.js

@@ -0,0 +1,27 @@
+"use strict";
+// ============================================================
+// Substructural Logics — Types (Linear + Affine)
+// ============================================================
+//
+// Logicas substructurales (Girard 1987 para Linear Logic, y Affine
+// como su variante con weakening) controlan los recursos:
+//
+//   - Linear:  ni contraction ni weakening. Cada formula del
+//              contexto se usa exactamente una vez.
+//   - Affine:  weakening permitido (descartar hipotesis), pero NO
+//              contraction (no duplicar). Cada formula se usa a lo
+//              sumo una vez.
+//
+// Conectivos del fragmento implementado:
+//   ⊗  (tensor)     — conjuncion multiplicativa, recursos juntos
+//   ⊸  (lollipop)   — implicacion lineal, consume premisa
+//   &  (with)       — conjuncion aditiva, elige uno de dos
+//   ⊕  (plus)       — disyuncion aditiva, alguno de los dos
+//   1               — unidad multiplicativa de ⊗
+//   !  (bang)       — exponencial "of course", habilita contraction
+//                     y weakening para el sub-recurso marcado
+//   ?  (whynot)     — exponencial dual del bang (presente como
+//                     constructor; en el fragmento intuicionista
+//                     fragmentario no se utiliza en reglas activas)
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=types.js.map

package/dist/profiles/substructural/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../src/profiles/substructural/types.ts"],"names":[],"mappings":";AAAA,+DAA+D;AAC/D,iDAAiD;AACjD,+DAA+D;AAC/D,EAAE;AACF,mEAAmE;AACnE,0DAA0D;AAC1D,EAAE;AACF,6DAA6D;AAC7D,oDAAoD;AACpD,kEAAkE;AAClE,mEAAmE;AACnE,6BAA6B;AAC7B,EAAE;AACF,yCAAyC;AACzC,iEAAiE;AACjE,0DAA0D;AAC1D,2DAA2D;AAC3D,4DAA4D;AAC5D,iDAAiD;AACjD,oEAAoE;AACpE,8DAA8D;AAC9D,+DAA+D;AAC/D,iEAAiE;AACjE,oEAAoE"}

package/dist/runtime/abduction/entails.d.ts

@@ -0,0 +1,21 @@
+import type { EntailmentOracle, Formula } from './types';
+export interface DefaultEntailsOptions {
+    /** Nombres tratados como variables. Default: `{x,y,z,u,v,w}`. */
+    variableNames?: ReadonlySet<string>;
+    /** Tope de iteraciones de forward-chaining. Default 1000. */
+    maxIterations?: number;
+}
+/**
+ * Oráculo de entailment por defecto. Forward-chaining sobre Horn-like.
+ *
+ * Devuelve `true` sii `target` (ground) es derivable de `premises`.
+ * Si `target` contiene variables se reporta `false` (no soportamos
+ * ∃-targets aquí; usar custom oracle).
+ */
+export declare function defaultEntails(opts?: DefaultEntailsOptions): EntailmentOracle;
+/**
+ * Oráculo de consistencia por defecto. Considera inconsistente sii
+ * el forward-chaining deriva un par {p, ¬p}.
+ */
+export declare function defaultConsistent(opts?: DefaultEntailsOptions): (premises: ReadonlyArray<Formula>) => boolean;
+//# sourceMappingURL=entails.d.ts.map

package/dist/runtime/abduction/entails.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"entails.d.ts","sourceRoot":"","sources":["../../../src/runtime/abduction/entails.ts"],"names":[],"mappings":"AA8BA,OAAO,KAAK,EAAE,gBAAgB,EAAE,OAAO,EAAE,MAAM,SAAS,CAAC;AAwQzD,MAAM,WAAW,qBAAqB;IACpC,iEAAiE;IACjE,aAAa,CAAC,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;IACpC,6DAA6D;IAC7D,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAED;;;;;;GAMG;AACH,wBAAgB,cAAc,CAAC,IAAI,GAAE,qBAA0B,GAAG,gBAAgB,CASjF;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAC/B,IAAI,GAAE,qBAA0B,GAC/B,CAAC,QAAQ,EAAE,aAAa,CAAC,OAAO,CAAC,KAAK,OAAO,CAO/C"}

package/dist/runtime/abduction/entails.js

@@ -0,0 +1,308 @@
+"use strict";
+// ============================================================
+// ST Abduction — Oráculo de entailment por defecto
+// ============================================================
+//
+// Implementación de entailment por forward-chaining sobre un
+// fragmento Horn con unificación simple:
+//
+//   Sintaxis soportada:
+//     - Átomos:   `p`, `bird(tweety)`, `parent(alice, bob)`
+//     - Reglas:   `A → B`  (también acepta `->`)
+//     - Reglas conjuntivas: `A ∧ B → C` (también `&&`, `and`, `,`)
+//     - Negación de conclusión: `A → ¬B` (también `~B`, `!B`)
+//
+//   Variables: identificadores que empiezan con letra minúscula y
+//   están dentro de argumentos de un predicado son variables
+//   universalmente cuantificadas (estilo Prolog implícito).
+//   Constantes: empiezan con mayúscula o son nombres entre comillas;
+//   los demás identificadores se tratan como variables si están
+//   dentro de un predicado.
+//
+//   Por convención de los tests del usuario, `bird(x)` tiene `x` como
+//   variable y `bird(tweety)` tiene `tweety` como constante: usamos
+//   un set de "variable names" configurable, default = nombres de
+//   una sola letra ASCII minúscula (`x`, `y`, `z`, `u`, `v`, `w`).
+//
+// Limitaciones consciente: no es un demostrador FOL completo. Es
+// suficiente para los casos de abducción típicos (diagnóstico,
+// Horn-like). Para fragmentos más ricos, pasar un `EntailmentOracle`
+// custom.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultEntails = defaultEntails;
+exports.defaultConsistent = defaultConsistent;
+// Reservamos un set chico de variable-names canónicas. Para casos
+// que necesiten más, pasar un EntailmentOracle propio.
+const DEFAULT_VARS = new Set(['x', 'y', 'z', 'u', 'v', 'w']);
+function tokenizeArgs(s) {
+    const out = [];
+    let depth = 0;
+    let cur = '';
+    for (const ch of s) {
+        if (ch === '(') {
+            depth++;
+            cur += ch;
+        }
+        else if (ch === ')') {
+            depth--;
+            cur += ch;
+        }
+        else if (ch === ',' && depth === 0) {
+            out.push(cur.trim());
+            cur = '';
+        }
+        else {
+            cur += ch;
+        }
+    }
+    if (cur.trim().length > 0)
+        out.push(cur.trim());
+    return out;
+}
+function parseAtom(rawIn) {
+    let raw = rawIn.trim();
+    let negated = false;
+    while (raw.startsWith('¬') || raw.startsWith('~') || raw.startsWith('!')) {
+        negated = !negated;
+        raw = raw.slice(1).trim();
+    }
+    const lp = raw.indexOf('(');
+    if (lp === -1) {
+        return { predicate: raw, args: [], negated };
+    }
+    const rp = raw.lastIndexOf(')');
+    if (rp === -1 || rp < lp) {
+        return { predicate: raw, args: [], negated };
+    }
+    const predicate = raw.slice(0, lp).trim();
+    const argsRaw = raw.slice(lp + 1, rp);
+    const args = tokenizeArgs(argsRaw);
+    return { predicate, args, negated };
+}
+function splitImplication(formula) {
+    // Soportar → (→), -> y =>.
+    const arrows = ['→', '->', '=>'];
+    for (const arr of arrows) {
+        const idx = formula.indexOf(arr);
+        if (idx >= 0) {
+            return {
+                lhs: formula.slice(0, idx).trim(),
+                rhs: formula.slice(idx + arr.length).trim(),
+            };
+        }
+    }
+    return null;
+}
+function splitConjunction(lhs) {
+    // Soportar ∧, &&, ` and ` (con espacios), y ',' (a tope).
+    // Procesamos a profundidad-0 para no romper args(a, b).
+    const seps = ['∧', '&&'];
+    for (const s of seps) {
+        if (lhs.includes(s)) {
+            return lhs
+                .split(s)
+                .map((p) => p.trim())
+                .filter((p) => p.length > 0);
+        }
+    }
+    // ' and ' como separador case-insensitive.
+    const andRegex = /\s+and\s+/i;
+    if (andRegex.test(lhs)) {
+        return lhs
+            .split(andRegex)
+            .map((p) => p.trim())
+            .filter((p) => p.length > 0);
+    }
+    // ',' a profundidad 0 (no dentro de args(...)).
+    const parts = [];
+    let depth = 0;
+    let cur = '';
+    for (const ch of lhs) {
+        if (ch === '(') {
+            depth++;
+            cur += ch;
+        }
+        else if (ch === ')') {
+            depth--;
+            cur += ch;
+        }
+        else if (ch === ',' && depth === 0) {
+            parts.push(cur.trim());
+            cur = '';
+        }
+        else {
+            cur += ch;
+        }
+    }
+    if (cur.trim().length > 0)
+        parts.push(cur.trim());
+    return parts.filter((p) => p.length > 0);
+}
+function parseFormula(formula) {
+    const imp = splitImplication(formula);
+    if (imp) {
+        const premises = splitConjunction(imp.lhs).map(parseAtom);
+        const conclusion = parseAtom(imp.rhs);
+        return { premises, conclusion };
+    }
+    return { premises: [], conclusion: parseAtom(formula) };
+}
+function isVariable(term, varNames) {
+    return varNames.has(term);
+}
+function atomKey(a) {
+    const sign = a.negated ? '¬' : '';
+    if (a.args.length === 0)
+        return `${sign}${a.predicate}`;
+    return `${sign}${a.predicate}(${a.args.join(',')})`;
+}
+/** Unifica `pattern` (puede tener vars) con `ground` (sin vars).
+ *  Retorna mapa var→constante o null si falla. Asume ground sin vars. */
+function unify(pattern, ground, varNames, subst) {
+    if (pattern.predicate !== ground.predicate)
+        return null;
+    if (pattern.negated !== ground.negated)
+        return null;
+    if (pattern.args.length !== ground.args.length)
+        return null;
+    const next = new Map(subst);
+    for (let i = 0; i < pattern.args.length; i++) {
+        const pa = pattern.args[i];
+        const ga = ground.args[i];
+        if (pa === undefined || ga === undefined)
+            return null;
+        if (isVariable(pa, varNames)) {
+            const bound = next.get(pa);
+            if (bound !== undefined) {
+                if (bound !== ga)
+                    return null;
+            }
+            else {
+                next.set(pa, ga);
+            }
+        }
+        else if (pa !== ga) {
+            return null;
+        }
+    }
+    return next;
+}
+function applySubst(a, subst) {
+    return {
+        predicate: a.predicate,
+        args: a.args.map((arg) => subst.get(arg) ?? arg),
+        negated: a.negated,
+    };
+}
+function isGround(a, varNames) {
+    return a.args.every((arg) => !isVariable(arg, varNames));
+}
+/** Forward-chaining: deriva el cierre de hechos a partir de premisas. */
+function forwardChain(premises, varNames, maxIterations = 1000) {
+    const parsed = premises.map(parseFormula);
+    const facts = new Set();
+    const rules = [];
+    for (const p of parsed) {
+        if (p.premises.length === 0 && isGround(p.conclusion, varNames)) {
+            facts.add(atomKey(p.conclusion));
+        }
+        else {
+            rules.push(p);
+        }
+    }
+    // Check trivial inconsistency en facts (p y ¬p ambos hechos).
+    for (const f of facts) {
+        if (f.startsWith('¬')) {
+            if (facts.has(f.slice(1)))
+                return { facts, inconsistent: true };
+        }
+        else {
+            if (facts.has(`¬${f}`))
+                return { facts, inconsistent: true };
+        }
+    }
+    let changed = true;
+    let iter = 0;
+    while (changed && iter < maxIterations) {
+        changed = false;
+        iter++;
+        for (const rule of rules) {
+            // Generar todas las substituciones que satisfacen las premisas.
+            const substitutions = matchPremises(rule.premises, facts, varNames);
+            for (const subst of substitutions) {
+                const conc = applySubst(rule.conclusion, subst);
+                if (!isGround(conc, varNames))
+                    continue;
+                const key = atomKey(conc);
+                if (!facts.has(key)) {
+                    // ¿Crea inconsistencia con un hecho existente?
+                    const opposite = conc.negated ? atomKey({ ...conc, negated: false }) : `¬${key}`;
+                    if (facts.has(opposite)) {
+                        facts.add(key);
+                        return { facts, inconsistent: true };
+                    }
+                    facts.add(key);
+                    changed = true;
+                }
+            }
+        }
+    }
+    return { facts, inconsistent: false };
+}
+/** Devuelve todas las substituciones que satisfacen una lista de premisas
+ *  contra el conjunto actual de hechos (ground). */
+function matchPremises(premises, facts, varNames) {
+    if (premises.length === 0)
+        return [new Map()];
+    // Parse facts a atoms ground una sola vez.
+    const groundAtoms = [];
+    for (const f of facts)
+        groundAtoms.push(parseAtom(f));
+    let cur = [new Map()];
+    for (const prem of premises) {
+        const next = [];
+        for (const subst of cur) {
+            const inst = applySubst(prem, subst);
+            for (const ga of groundAtoms) {
+                const u = unify(inst, ga, varNames, subst);
+                if (u !== null)
+                    next.push(u);
+            }
+        }
+        cur = next;
+        if (cur.length === 0)
+            return [];
+    }
+    return cur;
+}
+/**
+ * Oráculo de entailment por defecto. Forward-chaining sobre Horn-like.
+ *
+ * Devuelve `true` sii `target` (ground) es derivable de `premises`.
+ * Si `target` contiene variables se reporta `false` (no soportamos
+ * ∃-targets aquí; usar custom oracle).
+ */
+function defaultEntails(opts = {}) {
+    const varNames = opts.variableNames ?? DEFAULT_VARS;
+    const maxIter = opts.maxIterations ?? 1000;
+    return (premises, target) => {
+        const { facts } = forwardChain(premises, varNames, maxIter);
+        const targetAtom = parseAtom(target);
+        if (!isGround(targetAtom, varNames))
+            return false;
+        return facts.has(atomKey(targetAtom));
+    };
+}
+/**
+ * Oráculo de consistencia por defecto. Considera inconsistente sii
+ * el forward-chaining deriva un par {p, ¬p}.
+ */
+function defaultConsistent(opts = {}) {
+    const varNames = opts.variableNames ?? DEFAULT_VARS;
+    const maxIter = opts.maxIterations ?? 1000;
+    return (premises) => {
+        const { inconsistent } = forwardChain(premises, varNames, maxIter);
+        return !inconsistent;
+    };
+}
+//# sourceMappingURL=entails.js.map

package/dist/runtime/abduction/entails.js.map

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

package/dist/runtime/abduction/find.d.ts

@@ -0,0 +1,18 @@
+import type { AbductionOptions, AbductionProblem, Explanation } from './types';
+/**
+ * Encuentra todas las explicaciones de un problema abductivo.
+ *
+ * - Enumera subsets de abducibles en orden creciente de tamaño.
+ * - Filtra los inconsistentes y los que no implican la observación.
+ * - Calcula minimalidad por inclusión (parsimony) post-hoc.
+ * - Aplica el filtro `preferred` para el output final.
+ */
+export declare function findExplanations(problem: AbductionProblem, opts?: AbductionOptions): Explanation[];
+/**
+ * Devuelve UNA explicación: la "mejor" según `preferred`. Si hay
+ * empate, la primera en orden lex (consistente y reproducible).
+ *
+ * Devuelve `null` si no hay explicación posible.
+ */
+export declare function bestExplanation(problem: AbductionProblem, opts?: AbductionOptions): Explanation | null;
+//# sourceMappingURL=find.d.ts.map

package/dist/runtime/abduction/find.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"find.d.ts","sourceRoot":"","sources":["../../../src/runtime/abduction/find.ts"],"names":[],"mappings":"AAuBA,OAAO,KAAK,EACV,gBAAgB,EAChB,gBAAgB,EAGhB,WAAW,EAGZ,MAAM,SAAS,CAAC;AAwEjB;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,CAC9B,OAAO,EAAE,gBAAgB,EACzB,IAAI,CAAC,EAAE,gBAAgB,GACtB,WAAW,EAAE,CAsEf;AA6BD;;;;;GAKG;AACH,wBAAgB,eAAe,CAC7B,OAAO,EAAE,gBAAgB,EACzB,IAAI,CAAC,EAAE,gBAAgB,GACtB,WAAW,GAAG,IAAI,CAQpB"}