@stevenvo780/st-lang 4.7.0 → 4.8.0

package/dist/tooling/proof-guidance/search.js

@@ -0,0 +1,102 @@
+"use strict";
+// ============================================================
+// ST Proof Guidance — Beam search guiado por el modelo
+//
+// Hill-climbing relajado: en cada paso retenemos los `beamWidth`
+// estados con mejor score acumulado y expandimos solo esos.
+// El score se hereda del modelo (ranking) — el modelo guía qué
+// rama explorar primero.
+// ============================================================
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.guidedSearch = guidedSearch;
+const model_1 = require("./model");
+/**
+ * Reconoce un estado "cerrado" — goal vacío o `⊤` o reducido a una
+ * hipótesis idéntica. Hook minimalista; el caller puede pasar tácticas
+ * que devuelvan estados con goal = '' para indicar QED.
+ */
+function isClosed(state) {
+    const goal = state.goal.trim();
+    if (goal === '' || goal === '⊤')
+        return true;
+    if (state.hypotheses.some((h) => h.trim() === goal))
+        return true;
+    return false;
+}
+/**
+ * Hash determinístico de un estado para detectar ciclos en el beam.
+ * No es criptográfico — sólo evita re-expandir el mismo estado.
+ */
+function stateKey(state) {
+    // Hipótesis ordenadas para que {A, B} y {B, A} sean el mismo estado.
+    const hyps = state.hypotheses.slice().sort().join('|');
+    return `${state.goal.trim()}#${hyps}`;
+}
+/**
+ * Beam search guiado por el modelo. `applyTactic` define la semántica
+ * de cada táctica — el módulo no asume nada sobre la lógica de fondo.
+ */
+function guidedSearch(initialState, applyTactic, model, candidates, opts = {}) {
+    const maxDepth = opts.maxDepth ?? 16;
+    const beamWidth = Math.max(1, opts.beamWidth ?? 4);
+    const timeoutMs = opts.timeoutMs ?? 5000;
+    const maxExploredStates = opts.maxExploredStates ?? 10000;
+    const start = Date.now();
+    let explored = 0;
+    const visited = new Set();
+    visited.add(stateKey(initialState));
+    if (isClosed(initialState)) {
+        return { proof: [], exploredStates: 0, success: true };
+    }
+    let beam = [{ state: initialState, path: [], cumulativeScore: 0 }];
+    for (let depth = 0; depth < maxDepth; depth++) {
+        if (Date.now() - start > timeoutMs) {
+            return { exploredStates: explored, success: false, reason: 'timeout' };
+        }
+        if (explored >= maxExploredStates) {
+            return { exploredStates: explored, success: false, reason: 'cap' };
+        }
+        const nextBeam = [];
+        for (const node of beam) {
+            if (Date.now() - start > timeoutMs) {
+                return { exploredStates: explored, success: false, reason: 'timeout' };
+            }
+            const ranked = (0, model_1.rankTactics)(node.state, model, candidates);
+            for (const r of ranked) {
+                if (explored >= maxExploredStates)
+                    break;
+                const newState = applyTactic(node.state, r.tactic);
+                explored++;
+                if (newState === null)
+                    continue;
+                const key = stateKey(newState);
+                if (visited.has(key))
+                    continue;
+                visited.add(key);
+                const record = {
+                    tactic: r.tactic,
+                    beforeState: node.state,
+                    afterState: newState,
+                    successful: isClosed(newState),
+                };
+                const newPath = [...node.path, record];
+                if (isClosed(newState)) {
+                    return { proof: newPath, exploredStates: explored, success: true };
+                }
+                nextBeam.push({
+                    state: newState,
+                    path: newPath,
+                    cumulativeScore: node.cumulativeScore + r.score,
+                });
+            }
+        }
+        if (nextBeam.length === 0) {
+            return { exploredStates: explored, success: false, reason: 'exhausted' };
+        }
+        // Mantener los top-`beamWidth` por score acumulado.
+        nextBeam.sort((a, b) => b.cumulativeScore - a.cumulativeScore);
+        beam = nextBeam.slice(0, beamWidth);
+    }
+    return { exploredStates: explored, success: false, reason: 'depth' };
+}
+//# sourceMappingURL=search.js.map

package/dist/tooling/proof-guidance/search.js.map

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

package/dist/tooling/proof-guidance/types.d.ts

@@ -0,0 +1,77 @@
+/**
+ * Estado de prueba: goal a demostrar + hipótesis disponibles.
+ * `context` opcional para metadatos arbitrarios (nombre del teorema,
+ * profile lógico activo, etc.) — el extractor lo ignora hoy pero
+ * deja la puerta abierta para features ricas en el futuro.
+ */
+export interface ProofState {
+    goal: string;
+    hypotheses: string[];
+    context?: Record<string, string>;
+}
+/**
+ * Registro histórico: una aplicación de táctica con el resultado.
+ * `proofDepthRemaining` permite ponderar éxito por proximidad al QED:
+ * tácticas que cierran la prueba pesan más que tácticas medias.
+ */
+export interface TacticRecord {
+    tactic: string;
+    args?: unknown[];
+    beforeState: ProofState;
+    afterState: ProofState;
+    successful: boolean;
+    proofDepthRemaining?: number;
+}
+/**
+ * Feature extraída de un estado. `value` es numérico (los booleanos
+ * se codifican como 0/1) para que el ranker haga producto interno
+ * sin tratos especiales.
+ */
+export interface Feature {
+    name: string;
+    value: number;
+}
+/**
+ * Modelo entrenado. Por cada par (tactic, feature) hay un peso
+ * — los lemas también caben aquí porque se tratan como tácticas
+ * con nombre `lemma:<id>`.
+ */
+export interface RankingModel {
+    features: string[];
+    /** key: `${tactic}::${featureName}` → peso aprendido. */
+    weights: Map<string, number>;
+    /** bias por táctica — base rate cuando todas las features son 0. */
+    bias: Map<string, number>;
+}
+/**
+ * Resultado de ranking: score sin normalizar, mayor = mejor candidata.
+ * No es probabilidad estricta — usar `Math.exp(score) / sum` si se
+ * necesita softmax.
+ */
+export interface RankedTactic {
+    tactic: string;
+    score: number;
+}
+export interface SearchOptions {
+    /** Profundidad máxima de la prueba. Default: 16. */
+    maxDepth?: number;
+    /** Estados a expandir por nivel. Default: 4. */
+    beamWidth?: number;
+    /** Presupuesto de tiempo en milisegundos. Default: 5000. */
+    timeoutMs?: number;
+    /** Cap total de estados explorados (defensa contra explosiones). Default: 10000. */
+    maxExploredStates?: number;
+}
+export interface SearchResult {
+    /** Secuencia de tácticas si encontró prueba; undefined si falló. */
+    proof?: TacticRecord[];
+    /** Estados expandidos durante la búsqueda (métrica de costo). */
+    exploredStates: number;
+    /** true si llegó a un goal vacío o reconocido como cerrado. */
+    success: boolean;
+    /** Razón si no encontró: 'timeout' | 'depth' | 'exhausted'. */
+    reason?: 'timeout' | 'depth' | 'exhausted' | 'cap';
+}
+/** Función que aplica una táctica a un estado. null = táctica no aplicable. */
+export type ApplyTactic = (state: ProofState, tactic: string, args?: unknown[]) => ProofState | null;
+//# sourceMappingURL=types.d.ts.map

package/dist/tooling/proof-guidance/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/tooling/proof-guidance/types.ts"],"names":[],"mappings":"AAMA;;;;;GAKG;AACH,MAAM,WAAW,UAAU;IACzB,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,EAAE,MAAM,EAAE,CAAC;IACrB,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAClC;AAED;;;;GAIG;AACH,MAAM,WAAW,YAAY;IAC3B,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,CAAC,EAAE,OAAO,EAAE,CAAC;IACjB,WAAW,EAAE,UAAU,CAAC;IACxB,UAAU,EAAE,UAAU,CAAC;IACvB,UAAU,EAAE,OAAO,CAAC;IACpB,mBAAmB,CAAC,EAAE,MAAM,CAAC;CAC9B;AAED;;;;GAIG;AACH,MAAM,WAAW,OAAO;IACtB,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;CACf;AAED;;;;GAIG;AACH,MAAM,WAAW,YAAY;IAC3B,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,yDAAyD;IACzD,OAAO,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC7B,oEAAoE;IACpE,IAAI,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAC3B;AAED;;;;GAIG;AACH,MAAM,WAAW,YAAY;IAC3B,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,aAAa;IAC5B,oDAAoD;IACpD,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,gDAAgD;IAChD,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,4DAA4D;IAC5D,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,oFAAoF;IACpF,iBAAiB,CAAC,EAAE,MAAM,CAAC;CAC5B;AAED,MAAM,WAAW,YAAY;IAC3B,oEAAoE;IACpE,KAAK,CAAC,EAAE,YAAY,EAAE,CAAC;IACvB,iEAAiE;IACjE,cAAc,EAAE,MAAM,CAAC;IACvB,+DAA+D;IAC/D,OAAO,EAAE,OAAO,CAAC;IACjB,+DAA+D;IAC/D,MAAM,CAAC,EAAE,SAAS,GAAG,OAAO,GAAG,WAAW,GAAG,KAAK,CAAC;CACpD;AAED,+EAA+E;AAC/E,MAAM,MAAM,WAAW,GAAG,CACxB,KAAK,EAAE,UAAU,EACjB,MAAM,EAAE,MAAM,EACd,IAAI,CAAC,EAAE,OAAO,EAAE,KACb,UAAU,GAAG,IAAI,CAAC"}

package/dist/tooling/proof-guidance/types.js

@@ -0,0 +1,8 @@
+"use strict";
+// ============================================================
+// ST Proof Guidance — Tipos públicos
+// Sistema de ranking de tácticas/lemas con feature extraction
+// simple + aprendizaje supervisado (logistic regression / weighted KNN).
+// ============================================================
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=types.js.map

package/dist/tooling/proof-guidance/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../src/tooling/proof-guidance/types.ts"],"names":[],"mappings":";AAAA,+DAA+D;AAC/D,qCAAqC;AACrC,8DAA8D;AAC9D,yEAAyE;AACzE,+DAA+D"}

package/dist/type-theory/cubical/equality.d.ts

@@ -0,0 +1,4 @@
+import type { CubicalTerm } from './types';
+export declare function alphaEqCubical(a: CubicalTerm, b: CubicalTerm): boolean;
+export declare function alphaBetaEqCubical(a: CubicalTerm, b: CubicalTerm): boolean;
+//# sourceMappingURL=equality.d.ts.map

package/dist/type-theory/cubical/equality.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"equality.d.ts","sourceRoot":"","sources":["../../../src/type-theory/cubical/equality.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAM3C,wBAAgB,cAAc,CAAC,CAAC,EAAE,WAAW,EAAE,CAAC,EAAE,WAAW,GAAG,OAAO,CAoEtE;AAED,wBAAgB,kBAAkB,CAAC,CAAC,EAAE,WAAW,EAAE,CAAC,EAAE,WAAW,GAAG,OAAO,CAE1E"}

package/dist/type-theory/cubical/equality.js

@@ -0,0 +1,78 @@
+"use strict";
+// ============================================================
+// Cubical — α-equivalencia e igualdad definicional (αβ)
+// ============================================================
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.alphaEqCubical = alphaEqCubical;
+exports.alphaBetaEqCubical = alphaBetaEqCubical;
+const normalize_1 = require("./normalize");
+const substitute_1 = require("./substitute");
+let alphaCounter = 0;
+function alphaEqCubical(a, b) {
+    if (a.kind !== b.kind)
+        return false;
+    switch (a.kind) {
+        case 'i0':
+        case 'i1':
+            return true;
+        case 'universe':
+            return a.level === b.level;
+        case 'var':
+        case 'iVar':
+            return a.name === b.name;
+        case 'iNeg':
+            return alphaEqCubical(a.arg, b.arg);
+        case 'iMin':
+        case 'iMax': {
+            const bb = b;
+            return alphaEqCubical(a.left, bb.left) && alphaEqCubical(a.right, bb.right);
+        }
+        case 'pathP': {
+            const bb = b;
+            return (alphaEqCubical(a.family, bb.family) &&
+                alphaEqCubical(a.left, bb.left) &&
+                alphaEqCubical(a.right, bb.right));
+        }
+        case 'pLam': {
+            const bb = b;
+            if (a.bind === bb.bind)
+                return alphaEqCubical(a.body, bb.body);
+            const fresh = `__αc${alphaCounter++}`;
+            return alphaEqCubical((0, substitute_1.substituteCubical)(a.body, a.bind, { kind: 'iVar', name: fresh }), (0, substitute_1.substituteCubical)(bb.body, bb.bind, { kind: 'iVar', name: fresh }));
+        }
+        case 'pApp': {
+            const bb = b;
+            return alphaEqCubical(a.path, bb.path) && alphaEqCubical(a.arg, bb.arg);
+        }
+        case 'glue': {
+            const bb = b;
+            return alphaEqCubical(a.equiv, bb.equiv) && alphaEqCubical(a.partial, bb.partial);
+        }
+        case 'pi': {
+            const bb = b;
+            if (!alphaEqCubical(a.domain, bb.domain))
+                return false;
+            if (a.bind === bb.bind)
+                return alphaEqCubical(a.codomain, bb.codomain);
+            const fresh = `__αc${alphaCounter++}`;
+            return alphaEqCubical((0, substitute_1.substituteCubical)(a.codomain, a.bind, { kind: 'var', name: fresh }), (0, substitute_1.substituteCubical)(bb.codomain, bb.bind, { kind: 'var', name: fresh }));
+        }
+        case 'lam': {
+            const bb = b;
+            if (!alphaEqCubical(a.domain, bb.domain))
+                return false;
+            if (a.bind === bb.bind)
+                return alphaEqCubical(a.body, bb.body);
+            const fresh = `__αc${alphaCounter++}`;
+            return alphaEqCubical((0, substitute_1.substituteCubical)(a.body, a.bind, { kind: 'var', name: fresh }), (0, substitute_1.substituteCubical)(bb.body, bb.bind, { kind: 'var', name: fresh }));
+        }
+        case 'app': {
+            const bb = b;
+            return alphaEqCubical(a.fn, bb.fn) && alphaEqCubical(a.arg, bb.arg);
+        }
+    }
+}
+function alphaBetaEqCubical(a, b) {
+    return alphaEqCubical((0, normalize_1.normalizeCubical)(a), (0, normalize_1.normalizeCubical)(b));
+}
+//# sourceMappingURL=equality.js.map

package/dist/type-theory/cubical/equality.js.map

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

package/dist/type-theory/cubical/index.d.ts

@@ -0,0 +1,14 @@
+export type { CubicalTerm } from './types';
+export { cI0, cI1, cIVar, cIMin, cIMax, cINeg, cPathP, cPLam, cPApp, cGlue, cVar, cUniverse, cPi, cLam, cApp, cArrow, isIntervalExpr, freeVarsCubical, occursFreeCubical, termToStringCubical, } from './types';
+export { substituteCubical } from './substitute';
+export { evalInterval, normalizeInterval } from './interval';
+export type { IntervalValue } from './interval';
+export { reduceStepCubical, normalizeCubical, isNormalCubical } from './normalize';
+export { alphaEqCubical, alphaBetaEqCubical } from './equality';
+export { inferType, checkType, isInferErrorCubical, makeContext, intervalType } from './infer';
+export type { CubicalContext, InferResultCubical } from './infer';
+export { reflPath, pathInverse, pathCompose, glue } from './path-algebra';
+export { normalizeCubical as normalize } from './normalize';
+export { alphaBetaEqCubical as alphaBetaEq, alphaEqCubical as alphaEq } from './equality';
+export { termToStringCubical as termToString } from './types';
+//# sourceMappingURL=index.d.ts.map

package/dist/type-theory/cubical/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/type-theory/cubical/index.ts"],"names":[],"mappings":"AAgBA,YAAY,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAC3C,OAAO,EACL,GAAG,EACH,GAAG,EACH,KAAK,EACL,KAAK,EACL,KAAK,EACL,KAAK,EACL,MAAM,EACN,KAAK,EACL,KAAK,EACL,KAAK,EACL,IAAI,EACJ,SAAS,EACT,GAAG,EACH,IAAI,EACJ,IAAI,EACJ,MAAM,EACN,cAAc,EACd,eAAe,EACf,iBAAiB,EACjB,mBAAmB,GACpB,MAAM,SAAS,CAAC;AAEjB,OAAO,EAAE,iBAAiB,EAAE,MAAM,cAAc,CAAC;AACjD,OAAO,EAAE,YAAY,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAC7D,YAAY,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAChD,OAAO,EAAE,iBAAiB,EAAE,gBAAgB,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AACnF,OAAO,EAAE,cAAc,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAC;AAChE,OAAO,EAAE,SAAS,EAAE,SAAS,EAAE,mBAAmB,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAC/F,YAAY,EAAE,cAAc,EAAE,kBAAkB,EAAE,MAAM,SAAS,CAAC;AAClE,OAAO,EAAE,QAAQ,EAAE,WAAW,EAAE,WAAW,EAAE,IAAI,EAAE,MAAM,gBAAgB,CAAC;AAG1E,OAAO,EAAE,gBAAgB,IAAI,SAAS,EAAE,MAAM,aAAa,CAAC;AAC5D,OAAO,EAAE,kBAAkB,IAAI,WAAW,EAAE,cAAc,IAAI,OAAO,EAAE,MAAM,YAAY,CAAC;AAC1F,OAAO,EAAE,mBAAmB,IAAI,YAAY,EAAE,MAAM,SAAS,CAAC"}

package/dist/type-theory/cubical/index.js

@@ -0,0 +1,71 @@
+"use strict";
+// ============================================================
+// CTT-Lite — Cubical Type Theory (núcleo público)
+// ============================================================
+//
+// Extiende MLTT con:
+//   - Intervalo I con conexiones (∧, ∨) e involución (~)
+//   - PathP A x y como caminos dependientes en I
+//   - λi. t y p @ r (path-abstracción y aplicación)
+//   - Reducciones computacionales del intervalo
+//   - glue como precursor sintáctico de la computación de ua
+//
+// La diferencia central con HoTT (en /hott/) es que aquí univalence
+// es computacional: transport sobre un path generado por glue puede
+// reducir (en una versión completa de CTT). En este subset se sienta
+// la base sintáctica que permite esa reducción.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.termToString = exports.alphaEq = exports.alphaBetaEq = exports.normalize = exports.glue = exports.pathCompose = exports.pathInverse = exports.reflPath = exports.intervalType = exports.makeContext = exports.isInferErrorCubical = exports.checkType = exports.inferType = exports.alphaBetaEqCubical = exports.alphaEqCubical = exports.isNormalCubical = exports.normalizeCubical = exports.reduceStepCubical = exports.normalizeInterval = exports.evalInterval = exports.substituteCubical = exports.termToStringCubical = exports.occursFreeCubical = exports.freeVarsCubical = exports.isIntervalExpr = exports.cArrow = exports.cApp = exports.cLam = exports.cPi = exports.cUniverse = exports.cVar = exports.cGlue = exports.cPApp = exports.cPLam = exports.cPathP = exports.cINeg = exports.cIMax = exports.cIMin = exports.cIVar = exports.cI1 = exports.cI0 = void 0;
+var types_1 = require("./types");
+Object.defineProperty(exports, "cI0", { enumerable: true, get: function () { return types_1.cI0; } });
+Object.defineProperty(exports, "cI1", { enumerable: true, get: function () { return types_1.cI1; } });
+Object.defineProperty(exports, "cIVar", { enumerable: true, get: function () { return types_1.cIVar; } });
+Object.defineProperty(exports, "cIMin", { enumerable: true, get: function () { return types_1.cIMin; } });
+Object.defineProperty(exports, "cIMax", { enumerable: true, get: function () { return types_1.cIMax; } });
+Object.defineProperty(exports, "cINeg", { enumerable: true, get: function () { return types_1.cINeg; } });
+Object.defineProperty(exports, "cPathP", { enumerable: true, get: function () { return types_1.cPathP; } });
+Object.defineProperty(exports, "cPLam", { enumerable: true, get: function () { return types_1.cPLam; } });
+Object.defineProperty(exports, "cPApp", { enumerable: true, get: function () { return types_1.cPApp; } });
+Object.defineProperty(exports, "cGlue", { enumerable: true, get: function () { return types_1.cGlue; } });
+Object.defineProperty(exports, "cVar", { enumerable: true, get: function () { return types_1.cVar; } });
+Object.defineProperty(exports, "cUniverse", { enumerable: true, get: function () { return types_1.cUniverse; } });
+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, "isIntervalExpr", { enumerable: true, get: function () { return types_1.isIntervalExpr; } });
+Object.defineProperty(exports, "freeVarsCubical", { enumerable: true, get: function () { return types_1.freeVarsCubical; } });
+Object.defineProperty(exports, "occursFreeCubical", { enumerable: true, get: function () { return types_1.occursFreeCubical; } });
+Object.defineProperty(exports, "termToStringCubical", { enumerable: true, get: function () { return types_1.termToStringCubical; } });
+var substitute_1 = require("./substitute");
+Object.defineProperty(exports, "substituteCubical", { enumerable: true, get: function () { return substitute_1.substituteCubical; } });
+var interval_1 = require("./interval");
+Object.defineProperty(exports, "evalInterval", { enumerable: true, get: function () { return interval_1.evalInterval; } });
+Object.defineProperty(exports, "normalizeInterval", { enumerable: true, get: function () { return interval_1.normalizeInterval; } });
+var normalize_1 = require("./normalize");
+Object.defineProperty(exports, "reduceStepCubical", { enumerable: true, get: function () { return normalize_1.reduceStepCubical; } });
+Object.defineProperty(exports, "normalizeCubical", { enumerable: true, get: function () { return normalize_1.normalizeCubical; } });
+Object.defineProperty(exports, "isNormalCubical", { enumerable: true, get: function () { return normalize_1.isNormalCubical; } });
+var equality_1 = require("./equality");
+Object.defineProperty(exports, "alphaEqCubical", { enumerable: true, get: function () { return equality_1.alphaEqCubical; } });
+Object.defineProperty(exports, "alphaBetaEqCubical", { enumerable: true, get: function () { return equality_1.alphaBetaEqCubical; } });
+var infer_1 = require("./infer");
+Object.defineProperty(exports, "inferType", { enumerable: true, get: function () { return infer_1.inferType; } });
+Object.defineProperty(exports, "checkType", { enumerable: true, get: function () { return infer_1.checkType; } });
+Object.defineProperty(exports, "isInferErrorCubical", { enumerable: true, get: function () { return infer_1.isInferErrorCubical; } });
+Object.defineProperty(exports, "makeContext", { enumerable: true, get: function () { return infer_1.makeContext; } });
+Object.defineProperty(exports, "intervalType", { enumerable: true, get: function () { return infer_1.intervalType; } });
+var path_algebra_1 = require("./path-algebra");
+Object.defineProperty(exports, "reflPath", { enumerable: true, get: function () { return path_algebra_1.reflPath; } });
+Object.defineProperty(exports, "pathInverse", { enumerable: true, get: function () { return path_algebra_1.pathInverse; } });
+Object.defineProperty(exports, "pathCompose", { enumerable: true, get: function () { return path_algebra_1.pathCompose; } });
+Object.defineProperty(exports, "glue", { enumerable: true, get: function () { return path_algebra_1.glue; } });
+// Alias sin sufijo para uso ergonómico
+var normalize_2 = require("./normalize");
+Object.defineProperty(exports, "normalize", { enumerable: true, get: function () { return normalize_2.normalizeCubical; } });
+var equality_2 = require("./equality");
+Object.defineProperty(exports, "alphaBetaEq", { enumerable: true, get: function () { return equality_2.alphaBetaEqCubical; } });
+Object.defineProperty(exports, "alphaEq", { enumerable: true, get: function () { return equality_2.alphaEqCubical; } });
+var types_2 = require("./types");
+Object.defineProperty(exports, "termToString", { enumerable: true, get: function () { return types_2.termToStringCubical; } });
+//# sourceMappingURL=index.js.map

package/dist/type-theory/cubical/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/type-theory/cubical/index.ts"],"names":[],"mappings":";AAAA,+DAA+D;AAC/D,kDAAkD;AAClD,+DAA+D;AAC/D,EAAE;AACF,qBAAqB;AACrB,yDAAyD;AACzD,iDAAiD;AACjD,oDAAoD;AACpD,gDAAgD;AAChD,6DAA6D;AAC7D,EAAE;AACF,oEAAoE;AACpE,oEAAoE;AACpE,qEAAqE;AACrE,gDAAgD;;;AAGhD,iCAqBiB;AApBf,4FAAA,GAAG,OAAA;AACH,4FAAA,GAAG,OAAA;AACH,8FAAA,KAAK,OAAA;AACL,8FAAA,KAAK,OAAA;AACL,8FAAA,KAAK,OAAA;AACL,8FAAA,KAAK,OAAA;AACL,+FAAA,MAAM,OAAA;AACN,8FAAA,KAAK,OAAA;AACL,8FAAA,KAAK,OAAA;AACL,8FAAA,KAAK,OAAA;AACL,6FAAA,IAAI,OAAA;AACJ,kGAAA,SAAS,OAAA;AACT,4FAAA,GAAG,OAAA;AACH,6FAAA,IAAI,OAAA;AACJ,6FAAA,IAAI,OAAA;AACJ,+FAAA,MAAM,OAAA;AACN,uGAAA,cAAc,OAAA;AACd,wGAAA,eAAe,OAAA;AACf,0GAAA,iBAAiB,OAAA;AACjB,4GAAA,mBAAmB,OAAA;AAGrB,2CAAiD;AAAxC,+GAAA,iBAAiB,OAAA;AAC1B,uCAA6D;AAApD,wGAAA,YAAY,OAAA;AAAE,6GAAA,iBAAiB,OAAA;AAExC,yCAAmF;AAA1E,8GAAA,iBAAiB,OAAA;AAAE,6GAAA,gBAAgB,OAAA;AAAE,4GAAA,eAAe,OAAA;AAC7D,uCAAgE;AAAvD,0GAAA,cAAc,OAAA;AAAE,8GAAA,kBAAkB,OAAA;AAC3C,iCAA+F;AAAtF,kGAAA,SAAS,OAAA;AAAE,kGAAA,SAAS,OAAA;AAAE,4GAAA,mBAAmB,OAAA;AAAE,oGAAA,WAAW,OAAA;AAAE,qGAAA,YAAY,OAAA;AAE7E,+CAA0E;AAAjE,wGAAA,QAAQ,OAAA;AAAE,2GAAA,WAAW,OAAA;AAAE,2GAAA,WAAW,OAAA;AAAE,oGAAA,IAAI,OAAA;AAEjD,uCAAuC;AACvC,yCAA4D;AAAnD,sGAAA,gBAAgB,OAAa;AACtC,uCAA0F;AAAjF,uGAAA,kBAAkB,OAAe;AAAE,mGAAA,cAAc,OAAW;AACrE,iCAA8D;AAArD,qGAAA,mBAAmB,OAAgB"}

package/dist/type-theory/cubical/infer.d.ts

@@ -0,0 +1,18 @@
+import type { CubicalTerm } from './types';
+import { cArrow } from './types';
+export interface CubicalContext {
+    termVars: Map<string, CubicalTerm>;
+    intervalVars: Set<string>;
+}
+export type InferResultCubical = CubicalTerm | {
+    error: string;
+};
+export declare const intervalType: () => CubicalTerm;
+export declare function isInferErrorCubical(r: InferResultCubical): r is {
+    error: string;
+};
+export declare function makeContext(): CubicalContext;
+export declare function inferType(term: CubicalTerm, ctx?: CubicalContext): InferResultCubical;
+export declare function checkType(term: CubicalTerm, expected: CubicalTerm, ctx?: CubicalContext): boolean;
+export { cArrow };
+//# sourceMappingURL=infer.d.ts.map

package/dist/type-theory/cubical/infer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"infer.d.ts","sourceRoot":"","sources":["../../../src/type-theory/cubical/infer.ts"],"names":[],"mappings":"AA4BA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAC3C,OAAO,EAA0D,MAAM,EAAS,MAAM,SAAS,CAAC;AAKhG,MAAM,WAAW,cAAc;IAC7B,QAAQ,EAAE,GAAG,CAAC,MAAM,EAAE,WAAW,CAAC,CAAC;IACnC,YAAY,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;CAC3B;AAED,MAAM,MAAM,kBAAkB,GAAG,WAAW,GAAG;IAAE,KAAK,EAAE,MAAM,CAAA;CAAE,CAAC;AAEjE,eAAO,MAAM,YAAY,QAAO,WAA+C,CAAC;AAEhF,wBAAgB,mBAAmB,CAAC,CAAC,EAAE,kBAAkB,GAAG,CAAC,IAAI;IAAE,KAAK,EAAE,MAAM,CAAA;CAAE,CAEjF;AAED,wBAAgB,WAAW,IAAI,cAAc,CAE5C;AAoBD,wBAAgB,SAAS,CACvB,IAAI,EAAE,WAAW,EACjB,GAAG,GAAE,cAA8B,GAClC,kBAAkB,CAgJpB;AAgBD,wBAAgB,SAAS,CACvB,IAAI,EAAE,WAAW,EACjB,QAAQ,EAAE,WAAW,EACrB,GAAG,GAAE,cAA8B,GAClC,OAAO,CAIT;AAGD,OAAO,EAAE,MAAM,EAAE,CAAC"}