@stevenvo780/st-lang 4.11.0 → 4.13.0

package/dist/type-theory/lambda-cube/examples.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"examples.js","sourceRoot":"","sources":["../../../src/type-theory/lambda-cube/examples.ts"],"names":[],"mappings":"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"}

package/dist/type-theory/lambda-cube/index.d.ts

@@ -0,0 +1,11 @@
+export type { Sort, CubeSystem, CubeTerm, CubeContext } from './types';
+export { cVar, cSort, cStar, cBox, cPi, cLam, cApp, cArrow, occursFree, freeVars, termToString, alphaEq, emptyContext, extendContext, } from './types';
+export type { FormationRule, CubeRules } from './rules';
+export { SYSTEMS, hasRule, rulesOf, AXIOMS, axiomFor } from './rules';
+export { substitute, reduceStep, normalize, alphaBetaEq, isNormal } from './normalize';
+export type { InferError, InferResult } from './typecheck';
+export { inferType, checkType, isInferError, isClosedUnder } from './typecheck';
+export type { UntypedTerm, EraseError } from './erase';
+export { erase, isEraseError, untypedToString } from './erase';
+export { polymorphicIdentity, polymorphicIdentityType, churchNumeral, churchNumeralType, churchPairType, dependentList, predicateOverNat, typeLevelIdentity, typeLevelIdentityKind, cocPolyIdentityType, } from './examples';
+//# sourceMappingURL=index.d.ts.map

package/dist/type-theory/lambda-cube/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/type-theory/lambda-cube/index.ts"],"names":[],"mappings":"AAcA,YAAY,EAAE,IAAI,EAAE,UAAU,EAAE,QAAQ,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AACvE,OAAO,EACL,IAAI,EACJ,KAAK,EACL,KAAK,EACL,IAAI,EACJ,GAAG,EACH,IAAI,EACJ,IAAI,EACJ,MAAM,EACN,UAAU,EACV,QAAQ,EACR,YAAY,EACZ,OAAO,EACP,YAAY,EACZ,aAAa,GACd,MAAM,SAAS,CAAC;AAEjB,YAAY,EAAE,aAAa,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AACxD,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAEtE,OAAO,EAAE,UAAU,EAAE,UAAU,EAAE,SAAS,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAEvF,YAAY,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAC3D,OAAO,EAAE,SAAS,EAAE,SAAS,EAAE,YAAY,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAEhF,YAAY,EAAE,WAAW,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AACvD,OAAO,EAAE,KAAK,EAAE,YAAY,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAE/D,OAAO,EACL,mBAAmB,EACnB,uBAAuB,EACvB,aAAa,EACb,iBAAiB,EACjB,cAAc,EACd,aAAa,EACb,gBAAgB,EAChB,iBAAiB,EACjB,qBAAqB,EACrB,mBAAmB,GACpB,MAAM,YAAY,CAAC"}

package/dist/type-theory/lambda-cube/index.js

@@ -0,0 +1,64 @@
+"use strict";
+// ============================================================
+// Lambda Cube (Barendregt) — API pública
+// ============================================================
+//
+// Implementación uniforme de los 8 vértices del cubo λ como un Pure
+// Type System (PTS) parametrizado por el conjunto de reglas de
+// formación. Permite:
+//
+//   - inferType / checkType en cualquier vértice (λ→, λ2, λω, λC, ...).
+//   - normalize por β-reducción (call-by-name).
+//   - erase a λ-cálculo no tipado.
+//   - Construcciones canónicas: identity polimórfico, Church numerals,
+//     id-type operator, dependent list schema, etc.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cocPolyIdentityType = exports.typeLevelIdentityKind = exports.typeLevelIdentity = exports.predicateOverNat = exports.dependentList = exports.churchPairType = exports.churchNumeralType = exports.churchNumeral = exports.polymorphicIdentityType = exports.polymorphicIdentity = exports.untypedToString = exports.isEraseError = exports.erase = exports.isClosedUnder = exports.isInferError = exports.checkType = exports.inferType = exports.isNormal = exports.alphaBetaEq = exports.normalize = exports.reduceStep = exports.substitute = exports.axiomFor = exports.AXIOMS = exports.rulesOf = exports.hasRule = exports.SYSTEMS = exports.extendContext = exports.emptyContext = exports.alphaEq = exports.termToString = exports.freeVars = exports.occursFree = exports.cArrow = exports.cApp = exports.cLam = exports.cPi = exports.cBox = exports.cStar = exports.cSort = exports.cVar = void 0;
+var types_1 = require("./types");
+Object.defineProperty(exports, "cVar", { enumerable: true, get: function () { return types_1.cVar; } });
+Object.defineProperty(exports, "cSort", { enumerable: true, get: function () { return types_1.cSort; } });
+Object.defineProperty(exports, "cStar", { enumerable: true, get: function () { return types_1.cStar; } });
+Object.defineProperty(exports, "cBox", { enumerable: true, get: function () { return types_1.cBox; } });
+Object.defineProperty(exports, "cPi", { enumerable: true, get: function () { return types_1.cPi; } });
+Object.defineProperty(exports, "cLam", { enumerable: true, get: function () { return types_1.cLam; } });
+Object.defineProperty(exports, "cApp", { enumerable: true, get: function () { return types_1.cApp; } });
+Object.defineProperty(exports, "cArrow", { enumerable: true, get: function () { return types_1.cArrow; } });
+Object.defineProperty(exports, "occursFree", { enumerable: true, get: function () { return types_1.occursFree; } });
+Object.defineProperty(exports, "freeVars", { enumerable: true, get: function () { return types_1.freeVars; } });
+Object.defineProperty(exports, "termToString", { enumerable: true, get: function () { return types_1.termToString; } });
+Object.defineProperty(exports, "alphaEq", { enumerable: true, get: function () { return types_1.alphaEq; } });
+Object.defineProperty(exports, "emptyContext", { enumerable: true, get: function () { return types_1.emptyContext; } });
+Object.defineProperty(exports, "extendContext", { enumerable: true, get: function () { return types_1.extendContext; } });
+var rules_1 = require("./rules");
+Object.defineProperty(exports, "SYSTEMS", { enumerable: true, get: function () { return rules_1.SYSTEMS; } });
+Object.defineProperty(exports, "hasRule", { enumerable: true, get: function () { return rules_1.hasRule; } });
+Object.defineProperty(exports, "rulesOf", { enumerable: true, get: function () { return rules_1.rulesOf; } });
+Object.defineProperty(exports, "AXIOMS", { enumerable: true, get: function () { return rules_1.AXIOMS; } });
+Object.defineProperty(exports, "axiomFor", { enumerable: true, get: function () { return rules_1.axiomFor; } });
+var normalize_1 = require("./normalize");
+Object.defineProperty(exports, "substitute", { enumerable: true, get: function () { return normalize_1.substitute; } });
+Object.defineProperty(exports, "reduceStep", { enumerable: true, get: function () { return normalize_1.reduceStep; } });
+Object.defineProperty(exports, "normalize", { enumerable: true, get: function () { return normalize_1.normalize; } });
+Object.defineProperty(exports, "alphaBetaEq", { enumerable: true, get: function () { return normalize_1.alphaBetaEq; } });
+Object.defineProperty(exports, "isNormal", { enumerable: true, get: function () { return normalize_1.isNormal; } });
+var typecheck_1 = require("./typecheck");
+Object.defineProperty(exports, "inferType", { enumerable: true, get: function () { return typecheck_1.inferType; } });
+Object.defineProperty(exports, "checkType", { enumerable: true, get: function () { return typecheck_1.checkType; } });
+Object.defineProperty(exports, "isInferError", { enumerable: true, get: function () { return typecheck_1.isInferError; } });
+Object.defineProperty(exports, "isClosedUnder", { enumerable: true, get: function () { return typecheck_1.isClosedUnder; } });
+var erase_1 = require("./erase");
+Object.defineProperty(exports, "erase", { enumerable: true, get: function () { return erase_1.erase; } });
+Object.defineProperty(exports, "isEraseError", { enumerable: true, get: function () { return erase_1.isEraseError; } });
+Object.defineProperty(exports, "untypedToString", { enumerable: true, get: function () { return erase_1.untypedToString; } });
+var examples_1 = require("./examples");
+Object.defineProperty(exports, "polymorphicIdentity", { enumerable: true, get: function () { return examples_1.polymorphicIdentity; } });
+Object.defineProperty(exports, "polymorphicIdentityType", { enumerable: true, get: function () { return examples_1.polymorphicIdentityType; } });
+Object.defineProperty(exports, "churchNumeral", { enumerable: true, get: function () { return examples_1.churchNumeral; } });
+Object.defineProperty(exports, "churchNumeralType", { enumerable: true, get: function () { return examples_1.churchNumeralType; } });
+Object.defineProperty(exports, "churchPairType", { enumerable: true, get: function () { return examples_1.churchPairType; } });
+Object.defineProperty(exports, "dependentList", { enumerable: true, get: function () { return examples_1.dependentList; } });
+Object.defineProperty(exports, "predicateOverNat", { enumerable: true, get: function () { return examples_1.predicateOverNat; } });
+Object.defineProperty(exports, "typeLevelIdentity", { enumerable: true, get: function () { return examples_1.typeLevelIdentity; } });
+Object.defineProperty(exports, "typeLevelIdentityKind", { enumerable: true, get: function () { return examples_1.typeLevelIdentityKind; } });
+Object.defineProperty(exports, "cocPolyIdentityType", { enumerable: true, get: function () { return examples_1.cocPolyIdentityType; } });
+//# sourceMappingURL=index.js.map

package/dist/type-theory/lambda-cube/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/type-theory/lambda-cube/index.ts"],"names":[],"mappings":";AAAA,+DAA+D;AAC/D,yCAAyC;AACzC,+DAA+D;AAC/D,EAAE;AACF,oEAAoE;AACpE,+DAA+D;AAC/D,sBAAsB;AACtB,EAAE;AACF,wEAAwE;AACxE,gDAAgD;AAChD,mCAAmC;AACnC,uEAAuE;AACvE,oDAAoD;;;AAGpD,iCAeiB;AAdf,6FAAA,IAAI,OAAA;AACJ,8FAAA,KAAK,OAAA;AACL,8FAAA,KAAK,OAAA;AACL,6FAAA,IAAI,OAAA;AACJ,4FAAA,GAAG,OAAA;AACH,6FAAA,IAAI,OAAA;AACJ,6FAAA,IAAI,OAAA;AACJ,+FAAA,MAAM,OAAA;AACN,mGAAA,UAAU,OAAA;AACV,iGAAA,QAAQ,OAAA;AACR,qGAAA,YAAY,OAAA;AACZ,gGAAA,OAAO,OAAA;AACP,qGAAA,YAAY,OAAA;AACZ,sGAAA,aAAa,OAAA;AAIf,iCAAsE;AAA7D,gGAAA,OAAO,OAAA;AAAE,gGAAA,OAAO,OAAA;AAAE,gGAAA,OAAO,OAAA;AAAE,+FAAA,MAAM,OAAA;AAAE,iGAAA,QAAQ,OAAA;AAEpD,yCAAuF;AAA9E,uGAAA,UAAU,OAAA;AAAE,uGAAA,UAAU,OAAA;AAAE,sGAAA,SAAS,OAAA;AAAE,wGAAA,WAAW,OAAA;AAAE,qGAAA,QAAQ,OAAA;AAGjE,yCAAgF;AAAvE,sGAAA,SAAS,OAAA;AAAE,sGAAA,SAAS,OAAA;AAAE,yGAAA,YAAY,OAAA;AAAE,0GAAA,aAAa,OAAA;AAG1D,iCAA+D;AAAtD,8FAAA,KAAK,OAAA;AAAE,qGAAA,YAAY,OAAA;AAAE,wGAAA,eAAe,OAAA;AAE7C,uCAWoB;AAVlB,+GAAA,mBAAmB,OAAA;AACnB,mHAAA,uBAAuB,OAAA;AACvB,yGAAA,aAAa,OAAA;AACb,6GAAA,iBAAiB,OAAA;AACjB,0GAAA,cAAc,OAAA;AACd,yGAAA,aAAa,OAAA;AACb,4GAAA,gBAAgB,OAAA;AAChB,6GAAA,iBAAiB,OAAA;AACjB,iHAAA,qBAAqB,OAAA;AACrB,+GAAA,mBAAmB,OAAA"}

package/dist/type-theory/lambda-cube/normalize.d.ts

@@ -0,0 +1,17 @@
+import type { CubeSystem } from './types';
+import { type CubeTerm } from './types';
+/** Sustitución capture-avoiding: term[value/name]. */
+export declare function substitute(term: CubeTerm, name: string, value: CubeTerm): CubeTerm;
+/**
+ * Un paso de β-reducción top-down (call-by-name): si el término es
+ * `(λ x:A. b) arg`, devuelve `b[arg/x]`. Si no hay redex top-level,
+ * intenta reducir en sub-términos.
+ */
+export declare function reduceStep(term: CubeTerm): CubeTerm | undefined;
+/** Normaliza por reducción a normal-form. `maxSteps` evita loops divergentes. */
+export declare function normalize(term: CubeTerm, _system: CubeSystem, maxSteps?: number): CubeTerm;
+/** ¿Dos términos son iguales módulo α y β? */
+export declare function alphaBetaEq(a: CubeTerm, b: CubeTerm, system: CubeSystem): boolean;
+/** ¿El término está en forma normal (no quedan β-redex)? */
+export declare function isNormal(term: CubeTerm): boolean;
+//# sourceMappingURL=normalize.d.ts.map

package/dist/type-theory/lambda-cube/normalize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"normalize.d.ts","sourceRoot":"","sources":["../../../src/type-theory/lambda-cube/normalize.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AAC1C,OAAO,EAAE,KAAK,QAAQ,EAAqB,MAAM,SAAS,CAAC;AAU3D,sDAAsD;AACtD,wBAAgB,UAAU,CAAC,IAAI,EAAE,QAAQ,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,QAAQ,GAAG,QAAQ,CA2BlF;AA0BD;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,QAAQ,GAAG,QAAQ,GAAG,SAAS,CAgC/D;AAED,iFAAiF;AACjF,wBAAgB,SAAS,CAAC,IAAI,EAAE,QAAQ,EAAE,OAAO,EAAE,UAAU,EAAE,QAAQ,SAAO,GAAG,QAAQ,CAQxF;AAED,8CAA8C;AAC9C,wBAAgB,WAAW,CAAC,CAAC,EAAE,QAAQ,EAAE,CAAC,EAAE,QAAQ,EAAE,MAAM,EAAE,UAAU,GAAG,OAAO,CAKjF;AAED,4DAA4D;AAC5D,wBAAgB,QAAQ,CAAC,IAAI,EAAE,QAAQ,GAAG,OAAO,CAEhD"}

package/dist/type-theory/lambda-cube/normalize.js

@@ -0,0 +1,134 @@
+"use strict";
+// ============================================================
+// Lambda Cube — Sustitución capture-avoiding + β-normalización
+// ============================================================
+//
+// Al ser un Pure Type System, tipos y términos comparten sintaxis.
+// La β-reducción ocurre en cualquier sub-término, así que normalize
+// también reduce dentro de Π y dentro del dominio de λ.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.substitute = substitute;
+exports.reduceStep = reduceStep;
+exports.normalize = normalize;
+exports.alphaBetaEq = alphaBetaEq;
+exports.isNormal = isNormal;
+const types_1 = require("./types");
+let freshCounter = 0;
+function fresh(base, avoid) {
+    let candidate = `${base}#${freshCounter++}`;
+    while (avoid.has(candidate))
+        candidate = `${base}#${freshCounter++}`;
+    return candidate;
+}
+/** Sustitución capture-avoiding: term[value/name]. */
+function substitute(term, name, value) {
+    switch (term.kind) {
+        case 'var':
+            return term.name === name ? value : term;
+        case 'sort':
+            return term;
+        case 'pi':
+            return substBinder(term.bind, term.domain, term.codomain, name, value, (b, d, c) => ({
+                kind: 'pi',
+                bind: b,
+                domain: d,
+                codomain: c,
+            }));
+        case 'lam':
+            return substBinder(term.bind, term.domain, term.body, name, value, (b, d, c) => ({
+                kind: 'lam',
+                bind: b,
+                domain: d,
+                body: c,
+            }));
+        case 'app':
+            return {
+                kind: 'app',
+                fn: substitute(term.fn, name, value),
+                arg: substitute(term.arg, name, value),
+            };
+    }
+}
+function substBinder(bind, dom, body, name, value, build) {
+    const newDom = substitute(dom, name, value);
+    // Si el binder coincide con `name`, `body` no contiene `name` libre.
+    if (bind === name) {
+        return build(bind, newDom, body);
+    }
+    const fv = (0, types_1.freeVars)(value);
+    if (fv.has(bind)) {
+        const newBind = fresh(bind, new Set([...fv, ...(0, types_1.freeVars)(body), name]));
+        const renamed = substitute(body, bind, { kind: 'var', name: newBind });
+        return build(newBind, newDom, substitute(renamed, name, value));
+    }
+    return build(bind, newDom, substitute(body, name, value));
+}
+// ---------- β-reducción ----------
+/**
+ * Un paso de β-reducción top-down (call-by-name): si el término es
+ * `(λ x:A. b) arg`, devuelve `b[arg/x]`. Si no hay redex top-level,
+ * intenta reducir en sub-términos.
+ */
+function reduceStep(term) {
+    switch (term.kind) {
+        case 'var':
+        case 'sort':
+            return undefined;
+        case 'app': {
+            // β-redex top-level
+            if (term.fn.kind === 'lam') {
+                return substitute(term.fn.body, term.fn.bind, term.arg);
+            }
+            // Reducir fn primero (call-by-name)
+            const fnRed = reduceStep(term.fn);
+            if (fnRed)
+                return { kind: 'app', fn: fnRed, arg: term.arg };
+            const argRed = reduceStep(term.arg);
+            if (argRed)
+                return { kind: 'app', fn: term.fn, arg: argRed };
+            return undefined;
+        }
+        case 'pi': {
+            const dom = reduceStep(term.domain);
+            if (dom)
+                return { kind: 'pi', bind: term.bind, domain: dom, codomain: term.codomain };
+            const cod = reduceStep(term.codomain);
+            if (cod)
+                return { kind: 'pi', bind: term.bind, domain: term.domain, codomain: cod };
+            return undefined;
+        }
+        case 'lam': {
+            const dom = reduceStep(term.domain);
+            if (dom)
+                return { kind: 'lam', bind: term.bind, domain: dom, body: term.body };
+            const body = reduceStep(term.body);
+            if (body)
+                return { kind: 'lam', bind: term.bind, domain: term.domain, body };
+            return undefined;
+        }
+    }
+}
+/** Normaliza por reducción a normal-form. `maxSteps` evita loops divergentes. */
+function normalize(term, _system, maxSteps = 1000) {
+    let current = term;
+    for (let i = 0; i < maxSteps; i++) {
+        const next = reduceStep(current);
+        if (next === undefined)
+            return current;
+        current = next;
+    }
+    return current;
+}
+/** ¿Dos términos son iguales módulo α y β? */
+function alphaBetaEq(a, b, system) {
+    if ((0, types_1.alphaEq)(a, b))
+        return true;
+    const na = normalize(a, system);
+    const nb = normalize(b, system);
+    return (0, types_1.alphaEq)(na, nb);
+}
+/** ¿El término está en forma normal (no quedan β-redex)? */
+function isNormal(term) {
+    return reduceStep(term) === undefined;
+}
+//# sourceMappingURL=normalize.js.map

package/dist/type-theory/lambda-cube/normalize.js.map

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

package/dist/type-theory/lambda-cube/rules.d.ts

@@ -0,0 +1,26 @@
+import type { CubeSystem, Sort } from './types';
+export interface FormationRule {
+    from: Sort;
+    to: Sort;
+}
+export interface CubeRules {
+    formationRules: FormationRule[];
+}
+export declare const SYSTEMS: Record<CubeSystem, CubeRules>;
+/** ¿El par (s1, s2) está en las reglas de formación de `system`? */
+export declare function hasRule(system: CubeSystem, from: Sort, to: Sort): boolean;
+/** Conjunto de pares de formación de un sistema, en orden canónico. */
+export declare function rulesOf(system: CubeSystem): FormationRule[];
+/**
+ * Reglas de axioma. En el cubo Barendregt clásico el único axioma es
+ *   * : ◻
+ * (no hay jerarquía de universos: ◻ no tiene tipo propio, por eso los
+ * términos del cubo no pueden anidar ◻ : ?). Si se intentara tipar ◻
+ * directamente, el typechecker reportará error.
+ */
+export declare const AXIOMS: Array<{
+    sort: Sort;
+    type: Sort;
+}>;
+export declare function axiomFor(sort: Sort): Sort | undefined;
+//# sourceMappingURL=rules.d.ts.map

package/dist/type-theory/lambda-cube/rules.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rules.d.ts","sourceRoot":"","sources":["../../../src/type-theory/lambda-cube/rules.ts"],"names":[],"mappings":"AAmBA,OAAO,KAAK,EAAE,UAAU,EAAE,IAAI,EAAE,MAAM,SAAS,CAAC;AAEhD,MAAM,WAAW,aAAa;IAC5B,IAAI,EAAE,IAAI,CAAC;IACX,EAAE,EAAE,IAAI,CAAC;CACV;AAED,MAAM,WAAW,SAAS;IACxB,cAAc,EAAE,aAAa,EAAE,CAAC;CACjC;AAOD,eAAO,MAAM,OAAO,EAAE,MAAM,CAAC,UAAU,EAAE,SAAS,CASjD,CAAC;AAEF,oEAAoE;AACpE,wBAAgB,OAAO,CAAC,MAAM,EAAE,UAAU,EAAE,IAAI,EAAE,IAAI,EAAE,EAAE,EAAE,IAAI,GAAG,OAAO,CAMzE;AAED,uEAAuE;AACvE,wBAAgB,OAAO,CAAC,MAAM,EAAE,UAAU,GAAG,aAAa,EAAE,CAE3D;AAED;;;;;;GAMG;AACH,eAAO,MAAM,MAAM,EAAE,KAAK,CAAC;IAAE,IAAI,EAAE,IAAI,CAAC;IAAC,IAAI,EAAE,IAAI,CAAA;CAAE,CAA8B,CAAC;AAEpF,wBAAgB,QAAQ,CAAC,IAAI,EAAE,IAAI,GAAG,IAAI,GAAG,SAAS,CAKrD"}

package/dist/type-theory/lambda-cube/rules.js

@@ -0,0 +1,67 @@
+"use strict";
+// ============================================================
+// Lambda Cube — Pure Type System rules per vértice
+// ============================================================
+//
+// Cada sistema del cubo se identifica por su conjunto de reglas de
+// formación (s1, s2): bajo qué sorts es legal formar `Π x:A. B` donde
+// `A : s1` y `B : s2`.
+//
+// La regla común a todos los sistemas es (*, *) — la flecha sobre
+// términos del λ-cálculo simplemente tipado. Las otras tres se
+// "encienden" según la posición en el cubo:
+//
+//   eje X  (◻, *) — polimorfismo: cuantificar sobre tipos
+//   eje Y  (◻, ◻) — operadores de tipo: funciones type→type
+//   eje Z  (*, ◻) — tipos dependientes: tipo que depende de un valor
+//
+// Cualquier subconjunto que contenga (*, *) da un PTS coherente.
+// El número total de vértices es 2^3 = 8.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AXIOMS = exports.SYSTEMS = void 0;
+exports.hasRule = hasRule;
+exports.rulesOf = rulesOf;
+exports.axiomFor = axiomFor;
+const BASE = { from: '*', to: '*' };
+const POLY = { from: '◻', to: '*' };
+const OPS = { from: '◻', to: '◻' };
+const DEP = { from: '*', to: '◻' };
+exports.SYSTEMS = {
+    lambda: { formationRules: [BASE] },
+    lambda2: { formationRules: [BASE, POLY] },
+    'lambda-omega-bar': { formationRules: [BASE, OPS] },
+    'lambda-omega': { formationRules: [BASE, POLY, OPS] },
+    'lambda-P': { formationRules: [BASE, DEP] },
+    'lambda-P2': { formationRules: [BASE, POLY, DEP] },
+    'lambda-P-omega': { formationRules: [BASE, OPS, DEP] },
+    'lambda-C': { formationRules: [BASE, POLY, OPS, DEP] },
+};
+/** ¿El par (s1, s2) está en las reglas de formación de `system`? */
+function hasRule(system, from, to) {
+    const rules = exports.SYSTEMS[system].formationRules;
+    for (const r of rules) {
+        if (r.from === from && r.to === to)
+            return true;
+    }
+    return false;
+}
+/** Conjunto de pares de formación de un sistema, en orden canónico. */
+function rulesOf(system) {
+    return exports.SYSTEMS[system].formationRules;
+}
+/**
+ * Reglas de axioma. En el cubo Barendregt clásico el único axioma es
+ *   * : ◻
+ * (no hay jerarquía de universos: ◻ no tiene tipo propio, por eso los
+ * términos del cubo no pueden anidar ◻ : ?). Si se intentara tipar ◻
+ * directamente, el typechecker reportará error.
+ */
+exports.AXIOMS = [{ sort: '*', type: '◻' }];
+function axiomFor(sort) {
+    for (const a of exports.AXIOMS) {
+        if (a.sort === sort)
+            return a.type;
+    }
+    return undefined;
+}
+//# sourceMappingURL=rules.js.map

package/dist/type-theory/lambda-cube/rules.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"rules.js","sourceRoot":"","sources":["../../../src/type-theory/lambda-cube/rules.ts"],"names":[],"mappings":";AAAA,+DAA+D;AAC/D,mDAAmD;AACnD,+DAA+D;AAC/D,EAAE;AACF,mEAAmE;AACnE,sEAAsE;AACtE,uBAAuB;AACvB,EAAE;AACF,kEAAkE;AAClE,+DAA+D;AAC/D,4CAA4C;AAC5C,EAAE;AACF,0DAA0D;AAC1D,4DAA4D;AAC5D,qEAAqE;AACrE,EAAE;AACF,iEAAiE;AACjE,0CAA0C;;;AA8B1C,0BAMC;AAGD,0BAEC;AAWD,4BAKC;AA5CD,MAAM,IAAI,GAAkB,EAAE,IAAI,EAAE,GAAG,EAAE,EAAE,EAAE,GAAG,EAAE,CAAC;AACnD,MAAM,IAAI,GAAkB,EAAE,IAAI,EAAE,GAAG,EAAE,EAAE,EAAE,GAAG,EAAE,CAAC;AACnD,MAAM,GAAG,GAAkB,EAAE,IAAI,EAAE,GAAG,EAAE,EAAE,EAAE,GAAG,EAAE,CAAC;AAClD,MAAM,GAAG,GAAkB,EAAE,IAAI,EAAE,GAAG,EAAE,EAAE,EAAE,GAAG,EAAE,CAAC;AAErC,QAAA,OAAO,GAAkC;IACpD,MAAM,EAAE,EAAE,cAAc,EAAE,CAAC,IAAI,CAAC,EAAE;IAClC,OAAO,EAAE,EAAE,cAAc,EAAE,CAAC,IAAI,EAAE,IAAI,CAAC,EAAE;IACzC,kBAAkB,EAAE,EAAE,cAAc,EAAE,CAAC,IAAI,EAAE,GAAG,CAAC,EAAE;IACnD,cAAc,EAAE,EAAE,cAAc,EAAE,CAAC,IAAI,EAAE,IAAI,EAAE,GAAG,CAAC,EAAE;IACrD,UAAU,EAAE,EAAE,cAAc,EAAE,CAAC,IAAI,EAAE,GAAG,CAAC,EAAE;IAC3C,WAAW,EAAE,EAAE,cAAc,EAAE,CAAC,IAAI,EAAE,IAAI,EAAE,GAAG,CAAC,EAAE;IAClD,gBAAgB,EAAE,EAAE,cAAc,EAAE,CAAC,IAAI,EAAE,GAAG,EAAE,GAAG,CAAC,EAAE;IACtD,UAAU,EAAE,EAAE,cAAc,EAAE,CAAC,IAAI,EAAE,IAAI,EAAE,GAAG,EAAE,GAAG,CAAC,EAAE;CACvD,CAAC;AAEF,oEAAoE;AACpE,SAAgB,OAAO,CAAC,MAAkB,EAAE,IAAU,EAAE,EAAQ;IAC9D,MAAM,KAAK,GAAG,eAAO,CAAC,MAAM,CAAC,CAAC,cAAc,CAAC;IAC7C,KAAK,MAAM,CAAC,IAAI,KAAK,EAAE,CAAC;QACtB,IAAI,CAAC,CAAC,IAAI,KAAK,IAAI,IAAI,CAAC,CAAC,EAAE,KAAK,EAAE;YAAE,OAAO,IAAI,CAAC;IAClD,CAAC;IACD,OAAO,KAAK,CAAC;AACf,CAAC;AAED,uEAAuE;AACvE,SAAgB,OAAO,CAAC,MAAkB;IACxC,OAAO,eAAO,CAAC,MAAM,CAAC,CAAC,cAAc,CAAC;AACxC,CAAC;AAED;;;;;;GAMG;AACU,QAAA,MAAM,GAAsC,CAAC,EAAE,IAAI,EAAE,GAAG,EAAE,IAAI,EAAE,GAAG,EAAE,CAAC,CAAC;AAEpF,SAAgB,QAAQ,CAAC,IAAU;IACjC,KAAK,MAAM,CAAC,IAAI,cAAM,EAAE,CAAC;QACvB,IAAI,CAAC,CAAC,IAAI,KAAK,IAAI;YAAE,OAAO,CAAC,CAAC,IAAI,CAAC;IACrC,CAAC;IACD,OAAO,SAAS,CAAC;AACnB,CAAC"}

package/dist/type-theory/lambda-cube/typecheck.d.ts

@@ -0,0 +1,20 @@
+import { type CubeTerm, type CubeContext } from './types';
+import type { CubeSystem } from './types';
+export type InferError = {
+    error: string;
+};
+export type InferResult = CubeTerm | InferError;
+export declare function isInferError(r: InferResult): r is InferError;
+/**
+ * Infiere el tipo de `term` bajo `ctx` en el sistema dado. Devuelve
+ * el tipo, o `{ error }` si no es tipable.
+ */
+export declare function inferType(term: CubeTerm, ctx?: CubeContext, system?: CubeSystem): InferResult;
+/**
+ * Verifica que `term` tiene tipo `expected` bajo `ctx` en `system`.
+ * Igualdad de tipos: módulo α y β.
+ */
+export declare function checkType(term: CubeTerm, expected: CubeTerm, ctx?: CubeContext, system?: CubeSystem): boolean;
+/** ¿Las variables libres del término tienen todas un binding en `ctx`? */
+export declare function isClosedUnder(term: CubeTerm, ctx: CubeContext): boolean;
+//# sourceMappingURL=typecheck.d.ts.map

package/dist/type-theory/lambda-cube/typecheck.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"typecheck.d.ts","sourceRoot":"","sources":["../../../src/type-theory/lambda-cube/typecheck.ts"],"names":[],"mappings":"AAkCA,OAAO,EACL,KAAK,QAAQ,EACb,KAAK,WAAW,EAMjB,MAAM,SAAS,CAAC;AACjB,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AAI1C,MAAM,MAAM,UAAU,GAAG;IAAE,KAAK,EAAE,MAAM,CAAA;CAAE,CAAC;AAC3C,MAAM,MAAM,WAAW,GAAG,QAAQ,GAAG,UAAU,CAAC;AAEhD,wBAAgB,YAAY,CAAC,CAAC,EAAE,WAAW,GAAG,CAAC,IAAI,UAAU,CAE5D;AAWD;;;GAGG;AACH,wBAAgB,SAAS,CACvB,IAAI,EAAE,QAAQ,EACd,GAAG,GAAE,WAAuB,EAC5B,MAAM,GAAE,UAAuB,GAC9B,WAAW,CAoFb;AAED;;;GAGG;AACH,wBAAgB,SAAS,CACvB,IAAI,EAAE,QAAQ,EACd,QAAQ,EAAE,QAAQ,EAClB,GAAG,GAAE,WAAuB,EAC5B,MAAM,GAAE,UAAuB,GAC9B,OAAO,CAIT;AAED,0EAA0E;AAC1E,wBAAgB,aAAa,CAAC,IAAI,EAAE,QAAQ,EAAE,GAAG,EAAE,WAAW,GAAG,OAAO,CAKvE"}

package/dist/type-theory/lambda-cube/typecheck.js

@@ -0,0 +1,168 @@
+"use strict";
+// ============================================================
+// Lambda Cube — Pure Type System type-checker
+// ============================================================
+//
+// Algoritmo bidireccional uniforme para los 8 vértices del cubo. El
+// sistema activo se pasa como parámetro y restringe qué Π / λ son
+// legales mediante sus reglas de formación.
+//
+// Reglas PTS (versión cubo de Barendregt):
+//
+//   AX:       ⊢ * : ◻
+//   VAR:      Γ, x:A ⊢ x : A                  (si A está bien formado)
+//   APP:      Γ ⊢ f : (Π x:A. B)
+//             Γ ⊢ a : A
+//             ───────────────────
+//             Γ ⊢ f a : B[a/x]
+//
+//   LAM:      Γ, x:A ⊢ b : B
+//             Γ ⊢ (Π x:A. B) : s                (well-formed)
+//             ───────────────────────────
+//             Γ ⊢ (λ x:A. b) : (Π x:A. B)
+//
+//   PI:       Γ ⊢ A : s1
+//             Γ, x:A ⊢ B : s2
+//             (s1, s2) ∈ R(system)
+//             ───────────────────────
+//             Γ ⊢ (Π x:A. B) : s2
+//
+//   CONV:     Γ ⊢ t : A,  A =βη B,  Γ ⊢ B : s
+//             ──────────────────────────────────
+//             Γ ⊢ t : B
+//
+// Sin η, sin universos jerárquicos.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isInferError = isInferError;
+exports.inferType = inferType;
+exports.checkType = checkType;
+exports.isClosedUnder = isClosedUnder;
+const types_1 = require("./types");
+const rules_1 = require("./rules");
+const normalize_1 = require("./normalize");
+function isInferError(r) {
+    return typeof r === 'object' && r !== null && 'error' in r && typeof r.error === 'string';
+}
+/** Whnf parcial: normaliza solo lo necesario para revelar el head. */
+function whnf(term, system) {
+    return (0, normalize_1.normalize)(term, system);
+}
+function getSort(term) {
+    return term.kind === 'sort' ? term.sort : undefined;
+}
+/**
+ * Infiere el tipo de `term` bajo `ctx` en el sistema dado. Devuelve
+ * el tipo, o `{ error }` si no es tipable.
+ */
+function inferType(term, ctx = new Map(), system = 'lambda-C') {
+    switch (term.kind) {
+        case 'sort': {
+            const axiom = (0, rules_1.axiomFor)(term.sort);
+            if (axiom === undefined) {
+                return { error: `sort '${term.sort}' no tiene axioma de tipado` };
+            }
+            return (0, types_1.cSort)(axiom);
+        }
+        case 'var': {
+            const t = ctx.get(term.name);
+            if (!t)
+                return { error: `variable libre sin tipo: ${term.name}` };
+            return t;
+        }
+        case 'pi': {
+            // (PI) Γ ⊢ A : s1 ; Γ, x:A ⊢ B : s2 ; (s1,s2) ∈ R
+            const domType = inferType(term.domain, ctx, system);
+            if (isInferError(domType))
+                return domType;
+            const s1 = getSort(whnf(domType, system));
+            if (!s1) {
+                return {
+                    error: `dominio de Π debe ser un sort, pero ${(0, types_1.termToString)(term.domain)} : ${(0, types_1.termToString)(domType)}`,
+                };
+            }
+            const ctx2 = (0, types_1.extendContext)(ctx, term.bind, term.domain);
+            const codType = inferType(term.codomain, ctx2, system);
+            if (isInferError(codType))
+                return codType;
+            const s2 = getSort(whnf(codType, system));
+            if (!s2) {
+                return {
+                    error: `codominio de Π debe ser un sort, pero ${(0, types_1.termToString)(term.codomain)} : ${(0, types_1.termToString)(codType)}`,
+                };
+            }
+            if (!(0, rules_1.hasRule)(system, s1, s2)) {
+                return {
+                    error: `regla de formación (${s1}, ${s2}) no disponible en el sistema ${system}`,
+                };
+            }
+            return (0, types_1.cSort)(s2);
+        }
+        case 'lam': {
+            // (LAM) Γ, x:A ⊢ b : B ; Γ ⊢ Π x:A. B : s
+            const domType = inferType(term.domain, ctx, system);
+            if (isInferError(domType))
+                return domType;
+            const s1 = getSort(whnf(domType, system));
+            if (!s1) {
+                return {
+                    error: `parámetro de λ debe tener un tipo (sort), pero ${(0, types_1.termToString)(term.domain)} : ${(0, types_1.termToString)(domType)}`,
+                };
+            }
+            const ctx2 = (0, types_1.extendContext)(ctx, term.bind, term.domain);
+            const bodyType = inferType(term.body, ctx2, system);
+            if (isInferError(bodyType))
+                return bodyType;
+            // El Π reconstruido debe ser bien-formado en el sistema activo.
+            const piType = {
+                kind: 'pi',
+                bind: term.bind,
+                domain: term.domain,
+                codomain: bodyType,
+            };
+            const piSort = inferType(piType, ctx, system);
+            if (isInferError(piSort))
+                return piSort;
+            return piType;
+        }
+        case 'app': {
+            // (APP) f : (Π x:A. B) ; a : A ⟹ f a : B[a/x]
+            const fnType = inferType(term.fn, ctx, system);
+            if (isInferError(fnType))
+                return fnType;
+            const fnWhnf = whnf(fnType, system);
+            if (fnWhnf.kind !== 'pi') {
+                return {
+                    error: `aplicación requiere función Π, pero ${(0, types_1.termToString)(term.fn)} : ${(0, types_1.termToString)(fnType)}`,
+                };
+            }
+            const argType = inferType(term.arg, ctx, system);
+            if (isInferError(argType))
+                return argType;
+            if (!(0, normalize_1.alphaBetaEq)(argType, fnWhnf.domain, system)) {
+                return {
+                    error: `argumento incompatible: esperaba ${(0, types_1.termToString)(fnWhnf.domain)}, recibió ${(0, types_1.termToString)(argType)}`,
+                };
+            }
+            return (0, normalize_1.substitute)(fnWhnf.codomain, fnWhnf.bind, term.arg);
+        }
+    }
+}
+/**
+ * Verifica que `term` tiene tipo `expected` bajo `ctx` en `system`.
+ * Igualdad de tipos: módulo α y β.
+ */
+function checkType(term, expected, ctx = new Map(), system = 'lambda-C') {
+    const actual = inferType(term, ctx, system);
+    if (isInferError(actual))
+        return false;
+    return (0, normalize_1.alphaBetaEq)(actual, expected, system);
+}
+/** ¿Las variables libres del término tienen todas un binding en `ctx`? */
+function isClosedUnder(term, ctx) {
+    for (const fv of (0, types_1.freeVars)(term)) {
+        if (!ctx.has(fv))
+            return false;
+    }
+    return true;
+}
+//# sourceMappingURL=typecheck.js.map

package/dist/type-theory/lambda-cube/typecheck.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"typecheck.js","sourceRoot":"","sources":["../../../src/type-theory/lambda-cube/typecheck.ts"],"names":[],"mappings":"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"}

package/dist/type-theory/lambda-cube/types.d.ts

@@ -0,0 +1,40 @@
+export type Sort = '*' | '◻';
+export type CubeSystem = 'lambda' | 'lambda2' | 'lambda-omega-bar' | 'lambda-omega' | 'lambda-P' | 'lambda-P2' | 'lambda-P-omega' | 'lambda-C';
+export type CubeTerm = {
+    kind: 'var';
+    name: string;
+} | {
+    kind: 'sort';
+    sort: Sort;
+} | {
+    kind: 'pi';
+    bind: string;
+    domain: CubeTerm;
+    codomain: CubeTerm;
+} | {
+    kind: 'lam';
+    bind: string;
+    domain: CubeTerm;
+    body: CubeTerm;
+} | {
+    kind: 'app';
+    fn: CubeTerm;
+    arg: CubeTerm;
+};
+export declare const cVar: (name: string) => CubeTerm;
+export declare const cSort: (sort: Sort) => CubeTerm;
+export declare const cStar: CubeTerm;
+export declare const cBox: CubeTerm;
+export declare const cPi: (bind: string, domain: CubeTerm, codomain: CubeTerm) => CubeTerm;
+export declare const cLam: (bind: string, domain: CubeTerm, body: CubeTerm) => CubeTerm;
+export declare const cApp: (fn: CubeTerm, arg: CubeTerm) => CubeTerm;
+/** Flecha no-dependiente: Π (_ : A). B, cuando B no menciona el binder. */
+export declare const cArrow: (from: CubeTerm, to: CubeTerm) => CubeTerm;
+export declare function occursFree(name: string, term: CubeTerm): boolean;
+export declare function freeVars(term: CubeTerm, acc?: Set<string>): Set<string>;
+export declare function termToString(t: CubeTerm): string;
+export declare function alphaEq(a: CubeTerm, b: CubeTerm): boolean;
+export type CubeContext = Map<string, CubeTerm>;
+export declare function emptyContext(): CubeContext;
+export declare function extendContext(ctx: CubeContext, name: string, type: CubeTerm): CubeContext;
+//# sourceMappingURL=types.d.ts.map

package/dist/type-theory/lambda-cube/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/type-theory/lambda-cube/types.ts"],"names":[],"mappings":"AAsCA,MAAM,MAAM,IAAI,GAAG,GAAG,GAAG,GAAG,CAAC;AAE7B,MAAM,MAAM,UAAU,GAClB,QAAQ,GACR,SAAS,GACT,kBAAkB,GAClB,cAAc,GACd,UAAU,GACV,WAAW,GACX,gBAAgB,GAChB,UAAU,CAAC;AAEf,MAAM,MAAM,QAAQ,GAChB;IAAE,IAAI,EAAE,KAAK,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GAC7B;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,IAAI,CAAA;CAAE,GAC5B;IAAE,IAAI,EAAE,IAAI,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,QAAQ,CAAC;IAAC,QAAQ,EAAE,QAAQ,CAAA;CAAE,GAClE;IAAE,IAAI,EAAE,KAAK,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,QAAQ,CAAC;IAAC,IAAI,EAAE,QAAQ,CAAA;CAAE,GAC/D;IAAE,IAAI,EAAE,KAAK,CAAC;IAAC,EAAE,EAAE,QAAQ,CAAC;IAAC,GAAG,EAAE,QAAQ,CAAA;CAAE,CAAC;AAIjD,eAAO,MAAM,IAAI,GAAI,MAAM,MAAM,KAAG,QAAmC,CAAC;AACxE,eAAO,MAAM,KAAK,GAAI,MAAM,IAAI,KAAG,QAAoC,CAAC;AACxE,eAAO,MAAM,KAAK,EAAE,QAAsC,CAAC;AAC3D,eAAO,MAAM,IAAI,EAAE,QAAsC,CAAC;AAC1D,eAAO,MAAM,GAAG,GAAI,MAAM,MAAM,EAAE,QAAQ,QAAQ,EAAE,UAAU,QAAQ,KAAG,QAKvE,CAAC;AACH,eAAO,MAAM,IAAI,GAAI,MAAM,MAAM,EAAE,QAAQ,QAAQ,EAAE,MAAM,QAAQ,KAAG,QAKpE,CAAC;AACH,eAAO,MAAM,IAAI,GAAI,IAAI,QAAQ,EAAE,KAAK,QAAQ,KAAG,QAAsC,CAAC;AAE1F,2EAA2E;AAC3E,eAAO,MAAM,MAAM,GAAI,MAAM,QAAQ,EAAE,IAAI,QAAQ,KAAG,QAA8B,CAAC;AAIrF,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,QAAQ,GAAG,OAAO,CAgBhE;AAED,wBAAgB,QAAQ,CAAC,IAAI,EAAE,QAAQ,EAAE,GAAG,GAAE,GAAG,CAAC,MAAM,CAAa,GAAG,GAAG,CAAC,MAAM,CAAC,CAqBlF;AAID,wBAAgB,YAAY,CAAC,CAAC,EAAE,QAAQ,GAAG,MAAM,CA4BhD;AAID,wBAAgB,OAAO,CAAC,CAAC,EAAE,QAAQ,EAAE,CAAC,EAAE,QAAQ,GAAG,OAAO,CAEzD;AAiDD,MAAM,MAAM,WAAW,GAAG,GAAG,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC;AAEhD,wBAAgB,YAAY,IAAI,WAAW,CAE1C;AAED,wBAAgB,aAAa,CAAC,GAAG,EAAE,WAAW,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,QAAQ,GAAG,WAAW,CAIzF"}