@stevenvo780/st-lang 4.12.0 → 4.14.0

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

@@ -0,0 +1,26 @@
+import type { CubeTerm } from './types';
+export type UntypedTerm = {
+    kind: 'var';
+    name: string;
+} | {
+    kind: 'abs';
+    param: string;
+    body: UntypedTerm;
+} | {
+    kind: 'app';
+    fn: UntypedTerm;
+    arg: UntypedTerm;
+};
+export interface EraseError {
+    error: string;
+}
+export declare function isEraseError(r: UntypedTerm | EraseError): r is EraseError;
+/**
+ * Borrado total a λ-cálculo no tipado. Sorts y Π no tienen
+ * representante runtime — si aparecen como sub-término principal,
+ * el resultado es un error de borrado.
+ */
+export declare function erase(term: CubeTerm): UntypedTerm | EraseError;
+/** Serialización legible del λ-untyped. */
+export declare function untypedToString(t: UntypedTerm): string;
+//# sourceMappingURL=erase.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"erase.d.ts","sourceRoot":"","sources":["../../../src/type-theory/lambda-cube/erase.ts"],"names":[],"mappings":"AAiBA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAExC,MAAM,MAAM,WAAW,GACnB;IAAE,IAAI,EAAE,KAAK,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GAC7B;IAAE,IAAI,EAAE,KAAK,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,WAAW,CAAA;CAAE,GACjD;IAAE,IAAI,EAAE,KAAK,CAAC;IAAC,EAAE,EAAE,WAAW,CAAC;IAAC,GAAG,EAAE,WAAW,CAAA;CAAE,CAAC;AAEvD,MAAM,WAAW,UAAU;IACzB,KAAK,EAAE,MAAM,CAAC;CACf;AAED,wBAAgB,YAAY,CAAC,CAAC,EAAE,WAAW,GAAG,UAAU,GAAG,CAAC,IAAI,UAAU,CAEzE;AAED;;;;GAIG;AACH,wBAAgB,KAAK,CAAC,IAAI,EAAE,QAAQ,GAAG,WAAW,GAAG,UAAU,CAqB9D;AAED,2CAA2C;AAC3C,wBAAgB,eAAe,CAAC,CAAC,EAAE,WAAW,GAAG,MAAM,CAWtD"}

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

@@ -0,0 +1,68 @@
+"use strict";
+// ============================================================
+// Lambda Cube — Erasure a λ-cálculo no tipado
+// ============================================================
+//
+// La función de borrado (erasure / type-erasure) traduce un término
+// del cubo a un λ-término puro:
+//
+//   |x|            = x
+//   |s|            = ⊥  (sorts no tienen representante runtime)
+//   |λ x:A. b|     = λ x. |b|
+//   |Π x:A. B|     = ⊥  (los Π son tipos, no se ejecutan)
+//   |f a|          = |f| |a|
+//
+// El erasure preserva β: si `t →β t'` en el cubo entonces
+// `|t| →β |t'|` en λ-untyped. Esa es la base de la "phase distinction"
+// estándar de los sistemas de tipos polimórficos.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isEraseError = isEraseError;
+exports.erase = erase;
+exports.untypedToString = untypedToString;
+function isEraseError(r) {
+    return typeof r === 'object' && r !== null && 'error' in r && typeof r.error === 'string';
+}
+/**
+ * Borrado total a λ-cálculo no tipado. Sorts y Π no tienen
+ * representante runtime — si aparecen como sub-término principal,
+ * el resultado es un error de borrado.
+ */
+function erase(term) {
+    switch (term.kind) {
+        case 'var':
+            return { kind: 'var', name: term.name };
+        case 'sort':
+            return { error: `no se puede borrar el sort '${term.sort}' a λ-untyped` };
+        case 'pi':
+            return { error: `no se puede borrar un Π-type a λ-untyped` };
+        case 'lam': {
+            const body = erase(term.body);
+            if (isEraseError(body))
+                return body;
+            return { kind: 'abs', param: term.bind, body };
+        }
+        case 'app': {
+            const fn = erase(term.fn);
+            if (isEraseError(fn))
+                return fn;
+            const arg = erase(term.arg);
+            if (isEraseError(arg))
+                return arg;
+            return { kind: 'app', fn, arg };
+        }
+    }
+}
+/** Serialización legible del λ-untyped. */
+function untypedToString(t) {
+    switch (t.kind) {
+        case 'var':
+            return t.name;
+        case 'abs':
+            return `(λ${t.param}. ${untypedToString(t.body)})`;
+        case 'app': {
+            const arg = t.arg.kind === 'app' ? `(${untypedToString(t.arg)})` : untypedToString(t.arg);
+            return `(${untypedToString(t.fn)} ${arg})`;
+        }
+    }
+}
+//# sourceMappingURL=erase.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"erase.js","sourceRoot":"","sources":["../../../src/type-theory/lambda-cube/erase.ts"],"names":[],"mappings":";AAAA,+DAA+D;AAC/D,8CAA8C;AAC9C,+DAA+D;AAC/D,EAAE;AACF,oEAAoE;AACpE,gCAAgC;AAChC,EAAE;AACF,uBAAuB;AACvB,gEAAgE;AAChE,8BAA8B;AAC9B,0DAA0D;AAC1D,6BAA6B;AAC7B,EAAE;AACF,0DAA0D;AAC1D,uEAAuE;AACvE,kDAAkD;;AAalD,oCAEC;AAOD,sBAqBC;AAGD,0CAWC;AA5CD,SAAgB,YAAY,CAAC,CAA2B;IACtD,OAAO,OAAO,CAAC,KAAK,QAAQ,IAAI,CAAC,KAAK,IAAI,IAAI,OAAO,IAAI,CAAC,IAAI,OAAO,CAAC,CAAC,KAAK,KAAK,QAAQ,CAAC;AAC5F,CAAC;AAED;;;;GAIG;AACH,SAAgB,KAAK,CAAC,IAAc;IAClC,QAAQ,IAAI,CAAC,IAAI,EAAE,CAAC;QAClB,KAAK,KAAK;YACR,OAAO,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,IAAI,CAAC,IAAI,EAAE,CAAC;QAC1C,KAAK,MAAM;YACT,OAAO,EAAE,KAAK,EAAE,+BAA+B,IAAI,CAAC,IAAI,eAAe,EAAE,CAAC;QAC5E,KAAK,IAAI;YACP,OAAO,EAAE,KAAK,EAAE,0CAA0C,EAAE,CAAC;QAC/D,KAAK,KAAK,CAAC,CAAC,CAAC;YACX,MAAM,IAAI,GAAG,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;YAC9B,IAAI,YAAY,CAAC,IAAI,CAAC;gBAAE,OAAO,IAAI,CAAC;YACpC,OAAO,EAAE,IAAI,EAAE,KAAK,EAAE,KAAK,EAAE,IAAI,CAAC,IAAI,EAAE,IAAI,EAAE,CAAC;QACjD,CAAC;QACD,KAAK,KAAK,CAAC,CAAC,CAAC;YACX,MAAM,EAAE,GAAG,KAAK,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;YAC1B,IAAI,YAAY,CAAC,EAAE,CAAC;gBAAE,OAAO,EAAE,CAAC;YAChC,MAAM,GAAG,GAAG,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;YAC5B,IAAI,YAAY,CAAC,GAAG,CAAC;gBAAE,OAAO,GAAG,CAAC;YAClC,OAAO,EAAE,IAAI,EAAE,KAAK,EAAE,EAAE,EAAE,GAAG,EAAE,CAAC;QAClC,CAAC;IACH,CAAC;AACH,CAAC;AAED,2CAA2C;AAC3C,SAAgB,eAAe,CAAC,CAAc;IAC5C,QAAQ,CAAC,CAAC,IAAI,EAAE,CAAC;QACf,KAAK,KAAK;YACR,OAAO,CAAC,CAAC,IAAI,CAAC;QAChB,KAAK,KAAK;YACR,OAAO,KAAK,CAAC,CAAC,KAAK,KAAK,eAAe,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC;QACrD,KAAK,KAAK,CAAC,CAAC,CAAC;YACX,MAAM,GAAG,GAAG,CAAC,CAAC,GAAG,CAAC,IAAI,KAAK,KAAK,CAAC,CAAC,CAAC,IAAI,eAAe,CAAC,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC,eAAe,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC;YAC1F,OAAO,IAAI,eAAe,CAAC,CAAC,CAAC,EAAE,CAAC,IAAI,GAAG,GAAG,CAAC;QAC7C,CAAC;IACH,CAAC;AACH,CAAC"}

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

@@ -0,0 +1,59 @@
+import { type CubeTerm } from './types';
+/**
+ * Identidad polimórfica: λ X:*. λ x:X. x  ∈ λ2.
+ * Tipo: Π X:*. X → X.
+ */
+export declare function polymorphicIdentity(): CubeTerm;
+/** Tipo de la identidad polimórfica: Π X:*. X → X. */
+export declare function polymorphicIdentityType(): CubeTerm;
+/**
+ * Encoding Church de un natural `n` en System F:
+ *     n = λ X:*. λ s:X→X. λ z:X. s (s (... (s z) ...))   con n aplicaciones
+ *
+ * Tipo: Π X:*. (X → X) → X → X.
+ */
+export declare function churchNumeral(n: number): CubeTerm;
+/** Tipo de un natural Church: Π X:*. (X → X) → X → X. */
+export declare function churchNumeralType(): CubeTerm;
+/**
+ * Tipo polimórfico de pares: Π A:*. Π B:*. (Π C:*. (A → B → C) → C) → ...
+ * En la versión sencilla devolvemos solo el tipo de "Pair A B":
+ *
+ *   Π A:*. Π B:*. Π C:*. (A → B → C) → C
+ */
+export declare function churchPairType(): CubeTerm;
+/**
+ * Esquema de "lista dependiente": dado un tipo de vectores indexado
+ * por `Nat`, devolvemos el Π típico
+ *
+ *   Π n : Nat. Vector n
+ *
+ * Requiere que el contexto declare `Nat : *` y `Vector : Nat → *`.
+ * Atención: ambos extremos son `*`, así que esta Π usa la regla
+ * (*,*) y queda legal incluso en λ→ una vez que `Vector` está en el
+ * contexto. El sabor "dependiente" viene del hecho de que el
+ * codominio menciona el binder `n`.
+ */
+export declare function dependentList(): CubeTerm;
+/**
+ * Predicado sobre `Nat`: `Π n:Nat. *`. Domino `Nat : *` y codominio
+ * `*` (cuyo sort es `◻`). Esa es justo la formación (*,◻) — exclusiva
+ * de los vértices con tipos dependientes (λP, λP2, λPω, λC).
+ *
+ * Requiere `Nat : *` en el contexto.
+ */
+export declare function predicateOverNat(): CubeTerm;
+/**
+ * Operador de tipo `id-type`: λ A:*. A → A  en λω.
+ * Tipo: * → *.
+ */
+export declare function typeLevelIdentity(): CubeTerm;
+/** Tipo del operador `typeLevelIdentity`: * → *. */
+export declare function typeLevelIdentityKind(): CubeTerm;
+/**
+ * En el Calculus of Constructions, el tipo polimórfico
+ *   Π A:*. A → A
+ * vive en el universo `*`.
+ */
+export declare function cocPolyIdentityType(): CubeTerm;
+//# sourceMappingURL=examples.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"examples.d.ts","sourceRoot":"","sources":["../../../src/type-theory/lambda-cube/examples.ts"],"names":[],"mappings":"AAQA,OAAO,EAAE,KAAK,QAAQ,EAAwC,MAAM,SAAS,CAAC;AAE9E;;;GAGG;AACH,wBAAgB,mBAAmB,IAAI,QAAQ,CAE9C;AAED,sDAAsD;AACtD,wBAAgB,uBAAuB,IAAI,QAAQ,CAElD;AAED;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,CAAC,EAAE,MAAM,GAAG,QAAQ,CAUjD;AAED,yDAAyD;AACzD,wBAAgB,iBAAiB,IAAI,QAAQ,CAG5C;AAED;;;;;GAKG;AACH,wBAAgB,cAAc,IAAI,QAAQ,CAKzC;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,aAAa,IAAI,QAAQ,CAExC;AAED;;;;;;GAMG;AACH,wBAAgB,gBAAgB,IAAI,QAAQ,CAE3C;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,IAAI,QAAQ,CAE5C;AAED,oDAAoD;AACpD,wBAAgB,qBAAqB,IAAI,QAAQ,CAEhD;AAED;;;;GAIG;AACH,wBAAgB,mBAAmB,IAAI,QAAQ,CAE9C"}

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

@@ -0,0 +1,110 @@
+"use strict";
+// ============================================================
+// Lambda Cube — Términos canónicos
+// ============================================================
+//
+// Construcciones clásicas de cada vértice del cubo. Cada función
+// devuelve un `CubeTerm` directamente; el tipo correspondiente es
+// inferible con `inferType` en el sistema apropiado.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.polymorphicIdentity = polymorphicIdentity;
+exports.polymorphicIdentityType = polymorphicIdentityType;
+exports.churchNumeral = churchNumeral;
+exports.churchNumeralType = churchNumeralType;
+exports.churchPairType = churchPairType;
+exports.dependentList = dependentList;
+exports.predicateOverNat = predicateOverNat;
+exports.typeLevelIdentity = typeLevelIdentity;
+exports.typeLevelIdentityKind = typeLevelIdentityKind;
+exports.cocPolyIdentityType = cocPolyIdentityType;
+const types_1 = require("./types");
+/**
+ * Identidad polimórfica: λ X:*. λ x:X. x  ∈ λ2.
+ * Tipo: Π X:*. X → X.
+ */
+function polymorphicIdentity() {
+    return (0, types_1.cLam)('X', types_1.cStar, (0, types_1.cLam)('x', (0, types_1.cVar)('X'), (0, types_1.cVar)('x')));
+}
+/** Tipo de la identidad polimórfica: Π X:*. X → X. */
+function polymorphicIdentityType() {
+    return (0, types_1.cPi)('X', types_1.cStar, (0, types_1.cArrow)((0, types_1.cVar)('X'), (0, types_1.cVar)('X')));
+}
+/**
+ * Encoding Church de un natural `n` en System F:
+ *     n = λ X:*. λ s:X→X. λ z:X. s (s (... (s z) ...))   con n aplicaciones
+ *
+ * Tipo: Π X:*. (X → X) → X → X.
+ */
+function churchNumeral(n) {
+    if (!Number.isInteger(n) || n < 0) {
+        throw new Error(`churchNumeral requiere natural ≥ 0, recibió ${n}`);
+    }
+    const X = (0, types_1.cVar)('X');
+    let body = (0, types_1.cVar)('z');
+    for (let i = 0; i < n; i++) {
+        body = (0, types_1.cApp)((0, types_1.cVar)('s'), body);
+    }
+    return (0, types_1.cLam)('X', types_1.cStar, (0, types_1.cLam)('s', (0, types_1.cArrow)(X, X), (0, types_1.cLam)('z', X, body)));
+}
+/** Tipo de un natural Church: Π X:*. (X → X) → X → X. */
+function churchNumeralType() {
+    const X = (0, types_1.cVar)('X');
+    return (0, types_1.cPi)('X', types_1.cStar, (0, types_1.cArrow)((0, types_1.cArrow)(X, X), (0, types_1.cArrow)(X, X)));
+}
+/**
+ * Tipo polimórfico de pares: Π A:*. Π B:*. (Π C:*. (A → B → C) → C) → ...
+ * En la versión sencilla devolvemos solo el tipo de "Pair A B":
+ *
+ *   Π A:*. Π B:*. Π C:*. (A → B → C) → C
+ */
+function churchPairType() {
+    const A = (0, types_1.cVar)('A');
+    const B = (0, types_1.cVar)('B');
+    const C = (0, types_1.cVar)('C');
+    return (0, types_1.cPi)('A', types_1.cStar, (0, types_1.cPi)('B', types_1.cStar, (0, types_1.cPi)('C', types_1.cStar, (0, types_1.cArrow)((0, types_1.cArrow)(A, (0, types_1.cArrow)(B, C)), C))));
+}
+/**
+ * Esquema de "lista dependiente": dado un tipo de vectores indexado
+ * por `Nat`, devolvemos el Π típico
+ *
+ *   Π n : Nat. Vector n
+ *
+ * Requiere que el contexto declare `Nat : *` y `Vector : Nat → *`.
+ * Atención: ambos extremos son `*`, así que esta Π usa la regla
+ * (*,*) y queda legal incluso en λ→ una vez que `Vector` está en el
+ * contexto. El sabor "dependiente" viene del hecho de que el
+ * codominio menciona el binder `n`.
+ */
+function dependentList() {
+    return (0, types_1.cPi)('n', (0, types_1.cVar)('Nat'), (0, types_1.cApp)((0, types_1.cVar)('Vector'), (0, types_1.cVar)('n')));
+}
+/**
+ * Predicado sobre `Nat`: `Π n:Nat. *`. Domino `Nat : *` y codominio
+ * `*` (cuyo sort es `◻`). Esa es justo la formación (*,◻) — exclusiva
+ * de los vértices con tipos dependientes (λP, λP2, λPω, λC).
+ *
+ * Requiere `Nat : *` en el contexto.
+ */
+function predicateOverNat() {
+    return (0, types_1.cPi)('n', (0, types_1.cVar)('Nat'), types_1.cStar);
+}
+/**
+ * Operador de tipo `id-type`: λ A:*. A → A  en λω.
+ * Tipo: * → *.
+ */
+function typeLevelIdentity() {
+    return (0, types_1.cLam)('A', types_1.cStar, (0, types_1.cArrow)((0, types_1.cVar)('A'), (0, types_1.cVar)('A')));
+}
+/** Tipo del operador `typeLevelIdentity`: * → *. */
+function typeLevelIdentityKind() {
+    return (0, types_1.cArrow)(types_1.cStar, types_1.cStar);
+}
+/**
+ * En el Calculus of Constructions, el tipo polimórfico
+ *   Π A:*. A → A
+ * vive en el universo `*`.
+ */
+function cocPolyIdentityType() {
+    return (0, types_1.cPi)('A', types_1.cStar, (0, types_1.cArrow)((0, types_1.cVar)('A'), (0, types_1.cVar)('A')));
+}
+//# sourceMappingURL=examples.js.map

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