@stevenvo780/st-lang 2.7.1 → 3.0.0

package/dist/runtime/interpreter.js

@@ -15,9 +15,9 @@ require("../profiles");
 const compiler_1 = require("../text-layer/compiler");
 const formula_classifier_1 = require("./formula-classifier");
 const formula_factory_1 = require("./formula-factory");
-const MAX_CALL_DEPTH = 10000;
-const DEFAULT_MAX_RUNTIME_STEPS = 100000;
-const DEFAULT_MAX_RUNTIME_CALLS = 7000;
+const MAX_CALL_DEPTH = 50000;
+const DEFAULT_MAX_RUNTIME_STEPS = 500000;
+const DEFAULT_MAX_RUNTIME_CALLS = 100000;
 class Interpreter {
     theory;
     profile = null;
@@ -53,6 +53,13 @@ class Interpreter {
     /** Cache de resolución: fórmula original → fórmula resuelta (invalidado al cambiar bindings) */
     resolveCache = new WeakMap();
     resolveCacheGeneration = 0;
+    /** Memoización automática para funciones con argumentos numéricos (fibonacci, factorial, etc.) */
+    fnMemoCache = new Map();
+    static MEMO_CACHE_MAX = 50000;
+    /** v3: Formal definitions (define Name(params?) := body) */
+    definitions = new Map();
+    /** v3: Bibliographic sources */
+    sources = new Map();
     constructor() {
         this.theory = this.createEmptyTheory();
         this.textLayer = (0, compiler_1.createTextLayerState)();
@@ -116,7 +123,78 @@ class Interpreter {
         this.currentBindingFrame = null;
         this.runtimeStepCount = 0;
         this.runtimeCallCount = 0;
+        this.fnMemoCache.clear();
+        this.definitions.clear();
+        this.sources.clear();
+    }
+    // ── Memoización de funciones ──────────────────────────────
+    /** Serializa una fórmula a una cadena para usar como clave de cache */
+    serializeFormulaKey(f) {
+        if (f.kind === 'number')
+            return `N:${f.value}`;
+        if (f.kind === 'atom')
+            return `A:${f.name}`;
+        if (f.kind === 'list')
+            return `L:[${f.args?.map((a) => this.serializeFormulaKey(a)).join(',') ?? ''}]`;
+        return `${f.kind}(${f.args?.map((a) => this.serializeFormulaKey(a)).join(',') ?? ''})`;
+    }
+    /** Genera la clave de memoización: nombre_función(arg1,arg2,...) */
+    memoKey(name, args) {
+        // Solo memoizar si todos los argumentos son valores concretos (number, atom sin variables)
+        for (const arg of args) {
+            if (arg.kind !== 'number' && arg.kind !== 'atom')
+                return null;
+        }
+        return `${name}(${args.map((a) => this.serializeFormulaKey(a)).join(',')})`;
+    }
+    /** Verifica si una función es pura (sin side effects como print, set, check, axiom) */
+    isPureFn(fn) {
+        const check = (stmts) => {
+            for (const s of stmts) {
+                switch (s.kind) {
+                    case 'print_cmd':
+                    case 'set_cmd':
+                    case 'derive_cmd':
+                    case 'check_valid_cmd':
+                    case 'check_satisfiable_cmd':
+                    case 'check_equivalent_cmd':
+                    case 'prove_cmd':
+                    case 'axiom_decl':
+                    case 'theorem_decl':
+                    case 'theory_decl':
+                    case 'import_decl':
+                    case 'export_decl':
+                    case 'logic_decl':
+                    case 'glossary_cmd':
+                    case 'unfold_cmd':
+                    case 'fold_cmd':
+                        return false;
+                    case 'if_stmt': {
+                        const ifS = s;
+                        for (const branch of ifS.branches) {
+                            if (!check(branch.body))
+                                return false;
+                        }
+                        if (ifS.elseBranch && !check(ifS.elseBranch))
+                            return false;
+                        break;
+                    }
+                    case 'for_stmt':
+                        if (!check(s.body))
+                            return false;
+                        break;
+                    case 'while_stmt':
+                        if (!check(s.body))
+                            return false;
+                        break;
+                    // let_decl, return_stmt, fn_call, fn_decl are considered pure
+                }
+            }
+            return true;
+        };
+        return check(fn.body);
     }
+    // ── Fin memoización ───────────────────────────────────────
     getRuntimeStepLimit() {
         const configured = this.getBinding('max_steps') || this.getBinding('max_runtime_steps');
         if (configured?.kind === 'number' && configured.value && configured.value > 0) {
@@ -380,6 +458,18 @@ class Interpreter {
                 return;
             case 'export_decl':
                 return this.execExportDecl(stmt);
+            case 'define_decl':
+                return this.execDefineDecl(stmt);
+            case 'unfold_cmd':
+                return this.execUnfoldCmd(stmt);
+            case 'fold_cmd':
+                return this.execFoldCmd(stmt);
+            case 'source_decl':
+                return this.execSourceDecl(stmt);
+            case 'interpret_cmd':
+                return this.execInterpretCmd(stmt);
+            case 'glossary_cmd':
+                return this.execGlossaryCmd(stmt);
         }
     }
     executeStatementsIterative(statements, fallbackFile) {
@@ -548,6 +638,18 @@ class Interpreter {
                 return;
             case 'export_decl':
                 return this.execExportDecl(stmt);
+            case 'define_decl':
+                return this.execDefineDecl(stmt);
+            case 'unfold_cmd':
+                return this.execUnfoldCmd(stmt);
+            case 'fold_cmd':
+                return this.execFoldCmd(stmt);
+            case 'source_decl':
+                return this.execSourceDecl(stmt);
+            case 'interpret_cmd':
+                return this.execInterpretCmd(stmt);
+            case 'glossary_cmd':
+                return this.execGlossaryCmd(stmt);
         }
     }
     selectIfBody(stmt) {
@@ -665,6 +767,13 @@ class Interpreter {
             case 'theory_decl':
                 this.exportedTheories.set(s.name, this.theories.get(s.name));
                 break;
+            case 'define_decl': {
+                const defEntry = this.definitions.get(s.name);
+                if (defEntry) {
+                    this.exportedBindings.set(s.name, defEntry.body);
+                }
+                break;
+            }
         }
     }
     requireProfile() {
@@ -763,6 +872,32 @@ class Interpreter {
                 visited.delete(f.name);
                 return result;
             }
+            // v3: Expand definitions (no-param definitions referenced as atoms)
+            const def = this.definitions.get(f.name);
+            if (def && (!def.params || def.params.length === 0)) {
+                if (visited.has(f.name))
+                    return f;
+                visited.add(f.name);
+                const result = this.resolveFormulaRecursive(def.body, visited);
+                visited.delete(f.name);
+                return result;
+            }
+        }
+        // v3: Expand parametric definitions used as predicates: F(a, b)
+        if (f.kind === 'predicate' && f.name) {
+            const def = this.definitions.get(f.name);
+            if (def && def.params && def.params.length > 0) {
+                // Predicates store arguments as params (string[]) or args (Formula[])
+                let argFormulas;
+                if (f.args && f.args.length > 0) {
+                    argFormulas = f.args.map((a) => (a ? this.resolveFormulaRecursive(a, visited) : a));
+                }
+                else {
+                    argFormulas = (f.params ?? []).map((p) => ({ kind: 'atom', name: p, source: f.source }));
+                }
+                const expanded = this.substituteParams(def.body, def.params, argFormulas);
+                return this.resolveFormulaRecursive(expanded, visited);
+            }
         }
         // Llamada a función como expresión
         if (f.kind === 'fn_call' && f.name) {
@@ -1001,6 +1136,12 @@ class Interpreter {
     execRenderCmd(stmt) {
         const diags = (0, compiler_1.compileClaimsToTheory)(this.textLayer, this.theory);
         this.diagnostics.push(...diags);
+        if (stmt.target === 'glossary') {
+            return this.renderGlossary(stmt.format);
+        }
+        if (stmt.target === 'analysis') {
+            return this.renderAnalysis(stmt.format);
+        }
         if (stmt.target === 'claims' || stmt.target === 'all') {
             this.emit(`── Render: ${stmt.target} (${stmt.format}) ──`);
             for (const [name, claim] of this.theory.claims) {
@@ -1044,6 +1185,98 @@ class Interpreter {
             this.emit(`Render: ${stmt.target} (${stmt.format})`);
         }
     }
+    /** Render glossary in the specified format */
+    renderGlossary(format) {
+        if (format === 'json') {
+            const obj = {};
+            for (const [name, def] of this.definitions) {
+                obj[name] = {
+                    params: def.params ?? [],
+                    body: (0, propositional_1.formulaToString)(def.body),
+                    description: def.description ?? null,
+                };
+            }
+            this.emit(JSON.stringify(obj, null, 2));
+            return;
+        }
+        // markdown or default
+        if (this.definitions.size === 0) {
+            this.emit('(sin definiciones)');
+            return;
+        }
+        for (const [name, def] of this.definitions) {
+            const paramsStr = def.params?.length ? `(${def.params.join(', ')})` : '';
+            const bodyStr = format === 'latex' ? (0, format_1.formulaToLaTeX)(def.body) : (0, format_1.formulaToUnicode)(def.body);
+            if (format === 'latex') {
+                this.emit(`\\newcommand{\\${name}}{${bodyStr}} % ${def.description ?? ''}`);
+            }
+            else {
+                this.emit(`- **${name}${paramsStr}** := ${bodyStr}`);
+                if (def.description)
+                    this.emit(`  > ${def.description}`);
+            }
+        }
+    }
+    /** Render full analysis document */
+    renderAnalysis(format) {
+        const isLatex = format === 'latex';
+        const heading = (level, text) => {
+            if (isLatex)
+                return `${'\\'.repeat(1)}${'sub'.repeat(level - 1)}section{${text}}`;
+            return `${'#'.repeat(level)} ${text}`;
+        };
+        this.emit(heading(1, 'Análisis'));
+        this.emit('');
+        // Sources
+        if (this.sources.size > 0) {
+            this.emit(heading(2, 'Fuentes'));
+            for (const [, src] of this.sources) {
+                const yearStr = src.year ? ` (${src.year})` : '';
+                this.emit(`- ${src.author ?? ''}${yearStr} *${src.work ?? ''}*`);
+            }
+            this.emit('');
+        }
+        // Definitions
+        if (this.definitions.size > 0) {
+            this.emit(heading(2, 'Definiciones'));
+            this.renderGlossary(format);
+            this.emit('');
+        }
+        // Axioms
+        if (this.theory.axioms.size > 0) {
+            this.emit(heading(2, 'Axiomas'));
+            for (const [name, formula] of this.theory.axioms) {
+                this.emit(`- **${name}**: ${(0, format_1.formulaToUnicode)(formula)}`);
+            }
+            this.emit('');
+        }
+        // Theorems
+        if (this.theory.theorems.size > 0) {
+            this.emit(heading(2, 'Teoremas'));
+            for (const [name, formula] of this.theory.theorems) {
+                this.emit(`- **${name}**: ${(0, format_1.formulaToUnicode)(formula)}`);
+            }
+            this.emit('');
+        }
+        // Claims
+        if (this.theory.claims.size > 0) {
+            this.emit(heading(2, 'Claims'));
+            for (const [name, claim] of this.theory.claims) {
+                const fStr = claim.formula ? (0, format_1.formulaToUnicode)(claim.formula) : '(sin fórmula)';
+                this.emit(`- **${name}**: ${fStr}`);
+            }
+            this.emit('');
+        }
+        // Results summary
+        if (this.results.length > 0) {
+            this.emit(heading(2, 'Verificaciones'));
+            for (const r of this.results) {
+                const status = r.status === 'valid' ? '✓' : r.status === 'satisfiable' ? '~' : '✗';
+                const fStr = r.formula ? (0, format_1.formulaToUnicode)(r.formula) : '';
+                this.emit(`- ${fStr}: ${r.status} ${status}`);
+            }
+        }
+    }
     execAnalyzeCmd(stmt) {
         const profile = this.requireProfile();
         const premises = stmt.premises.map((p) => this.resolveFormula(p));
@@ -1272,10 +1505,261 @@ class Interpreter {
             this.returnValue = undefined;
         this.returnSignal = true;
     }
+    // ── v3: Definitions, sources, glossary ──────────────────────────
+    execDefineDecl(stmt) {
+        // Check for circular definitions
+        this.checkCircularDefinition(stmt.name, stmt.body, new Set());
+        const entry = {
+            name: stmt.name,
+            params: stmt.params,
+            body: stmt.body,
+            description: stmt.description,
+        };
+        this.definitions.set(stmt.name, entry);
+        const diags = (0, compiler_1.registerDefinition)(this.textLayer, entry);
+        this.diagnostics.push(...diags);
+        this.invalidateResolveCache();
+        const paramsStr = stmt.params?.length ? `(${stmt.params.join(', ')})` : '';
+        const bodyStr = (0, format_1.formulaToUnicode)(stmt.body);
+        this.emit(`Define ${stmt.name}${paramsStr} := ${bodyStr}`);
+        if (stmt.description) {
+            this.emit(`  → "${stmt.description}"`);
+        }
+    }
+    /** Detect circular definitions (A := ... A ...) */
+    checkCircularDefinition(name, body, visited) {
+        if (!body)
+            return;
+        if (body.kind === 'atom' && body.name) {
+            if (body.name === name) {
+                throw new Error(`Definición circular detectada: '${name}' se refiere a sí mismo`);
+            }
+            if (visited.has(body.name))
+                return;
+            visited.add(body.name);
+            const dep = this.definitions.get(body.name);
+            if (dep) {
+                this.checkCircularDefinition(name, dep.body, visited);
+            }
+        }
+        if (body.args) {
+            for (const arg of body.args) {
+                if (arg)
+                    this.checkCircularDefinition(name, arg, visited);
+            }
+        }
+    }
+    /** Expand a definition by name with given arguments */
+    expandDefinition(name, args) {
+        const def = this.definitions.get(name);
+        if (!def)
+            return null;
+        // If definition has no params, return body directly
+        if (!def.params || def.params.length === 0) {
+            return def.body;
+        }
+        // Substitute params with args
+        const actualArgs = args ?? [];
+        return this.substituteParams(def.body, def.params, actualArgs);
+    }
+    /** Recursively substitute parameter names with actual argument formulas */
+    substituteParams(formula, params, args) {
+        if (!formula)
+            return formula;
+        if (formula.kind === 'atom' && formula.name) {
+            const idx = params.indexOf(formula.name);
+            if (idx >= 0 && idx < args.length) {
+                return args[idx];
+            }
+            return formula;
+        }
+        if (formula.args && formula.args.length > 0) {
+            const newArgs = formula.args.map((a) => (a ? this.substituteParams(a, params, args) : a));
+            let changed = false;
+            for (let i = 0; i < formula.args.length; i++) {
+                if (formula.args[i] !== newArgs[i]) {
+                    changed = true;
+                    break;
+                }
+            }
+            return changed ? { ...formula, args: newArgs } : formula;
+        }
+        return formula;
+    }
+    /** Expand all definitions in a formula (one level) */
+    expandDefinitionsInFormula(f) {
+        if (!f)
+            return f;
+        // If atom matches a definition name (no params), expand it
+        if (f.kind === 'atom' && f.name) {
+            const expanded = this.expandDefinition(f.name);
+            if (expanded)
+                return expanded;
+        }
+        // If it's a predicate-like call (name with args), try to expand parametric definition
+        if (f.kind === 'predicate' && f.name) {
+            const def = this.definitions.get(f.name);
+            if (def && def.params && def.params.length > 0 && f.args) {
+                const expanded = this.expandDefinition(f.name, f.args);
+                if (expanded)
+                    return expanded;
+            }
+        }
+        // Recurse into sub-formulas
+        if (f.args && f.args.length > 0) {
+            const newArgs = f.args.map((a) => (a ? this.expandDefinitionsInFormula(a) : a));
+            let changed = false;
+            for (let i = 0; i < f.args.length; i++) {
+                if (f.args[i] !== newArgs[i]) {
+                    changed = true;
+                    break;
+                }
+            }
+            return changed ? { ...f, args: newArgs } : f;
+        }
+        return f;
+    }
+    /** Try to fold a formula back into a definition reference */
+    foldFormula(f) {
+        const fStr = (0, propositional_1.formulaToString)(f);
+        for (const [name, def] of this.definitions) {
+            if (!def.params || def.params.length === 0) {
+                const defStr = (0, propositional_1.formulaToString)(def.body);
+                if (fStr === defStr) {
+                    return { kind: 'atom', name, source: f.source };
+                }
+            }
+        }
+        return f;
+    }
+    execUnfoldCmd(stmt) {
+        const resolved = this.resolveFormulaRecursive(stmt.formula, new Set());
+        const expanded = this.expandDefinitionsInFormula(resolved);
+        const expandedStr = (0, format_1.formulaToUnicode)(expanded);
+        this.emit(`Unfold: ${(0, format_1.formulaToUnicode)(resolved)} → ${expandedStr}`);
+        this.results.push({
+            status: 'valid',
+            output: expandedStr,
+            diagnostics: [],
+            formula: expanded,
+        });
+    }
+    execFoldCmd(stmt) {
+        const resolved = this.resolveFormulaRecursive(stmt.formula, new Set());
+        const folded = this.foldFormula(resolved);
+        const foldedStr = (0, format_1.formulaToUnicode)(folded);
+        this.emit(`Fold: ${(0, format_1.formulaToUnicode)(resolved)} → ${foldedStr}`);
+        this.results.push({
+            status: 'valid',
+            output: foldedStr,
+            diagnostics: [],
+            formula: folded,
+        });
+    }
+    execSourceDecl(stmt) {
+        const info = { id: stmt.name };
+        for (const field of stmt.fields) {
+            switch (field.key) {
+                case 'author':
+                    info.author = String(field.value);
+                    break;
+                case 'work':
+                    info.work = String(field.value);
+                    break;
+                case 'year':
+                    info.year = typeof field.value === 'number' ? field.value : parseInt(String(field.value));
+                    break;
+                case 'section':
+                    info.section = String(field.value);
+                    break;
+                case 'edition':
+                    info.edition = String(field.value);
+                    break;
+                case 'url':
+                    info.url = String(field.value);
+                    break;
+            }
+        }
+        this.sources.set(stmt.name, info);
+        const diags = (0, compiler_1.registerSource)(this.textLayer, info);
+        this.diagnostics.push(...diags);
+        const yearStr = info.year ? ` (${info.year})` : '';
+        this.emit(`Source ${stmt.name}: ${info.author ?? ''}${yearStr} — ${info.work ?? ''}`);
+    }
+    execInterpretCmd(stmt) {
+        const formula = this.resolveFormula(stmt.formula);
+        const key = stmt.passageRef ?? stmt.text;
+        const diags = (0, compiler_1.registerInterpretation)(this.textLayer, key, {
+            text: stmt.text,
+            passageRef: stmt.passageRef,
+            formula,
+        });
+        this.diagnostics.push(...diags);
+        // Also register as a let binding so the interpretation is available as a named formula
+        const bindingName = stmt.text.replace(/\s+/g, '_').replace(/[^a-zA-Z0-9_]/g, '');
+        if (bindingName) {
+            this.defineBinding(bindingName, formula);
+        }
+        this.emit(`Interpret: "${stmt.text}" → ${(0, format_1.formulaToUnicode)(formula)}`);
+    }
+    execGlossaryCmd(_stmt) {
+        this.emit('');
+        this.emit('══════════════════════════════════════');
+        this.emit('  GLOSARIO');
+        this.emit('══════════════════════════════════════');
+        if (this.definitions.size === 0) {
+            this.emit('  (sin definiciones registradas)');
+        }
+        else {
+            for (const [name, def] of this.definitions) {
+                const paramsStr = def.params?.length ? `(${def.params.join(', ')})` : '';
+                const bodyStr = (0, format_1.formulaToUnicode)(def.body);
+                this.emit(`  ${name}${paramsStr}  :=  ${bodyStr}`);
+                if (def.description) {
+                    this.emit(`      "${def.description}"`);
+                }
+            }
+        }
+        // Also show sources if any
+        if (this.sources.size > 0) {
+            this.emit('');
+            this.emit('── Fuentes ──');
+            for (const [, src] of this.sources) {
+                const yearStr = src.year ? ` (${src.year})` : '';
+                this.emit(`  ${src.id}: ${src.author ?? ''}${yearStr} — ${src.work ?? ''}`);
+            }
+        }
+        // Show interpretations if any
+        if (this.textLayer.interpretations.size > 0) {
+            this.emit('');
+            this.emit('── Interpretaciones ──');
+            for (const [, interp] of this.textLayer.interpretations) {
+                this.emit(`  "${interp.text}" → ${(0, format_1.formulaToUnicode)(interp.formula)}`);
+            }
+        }
+        this.emit('══════════════════════════════════════');
+        this.emit('');
+    }
+    // ── End v3 ─────────────────────────────────────────────────
     executeFnCall(stmt) {
-        const initial = this.startFunctionFrame(stmt, undefined);
-        if ('result' in initial)
+        // ── Memoización: verificar cache antes de ejecutar ──
+        const evaluatedArgs = stmt.args.map((a) => this.evaluateFormulaValue(a));
+        const memoStmt = { name: stmt.name, args: evaluatedArgs };
+        const fn = this.functions.get(stmt.name);
+        let mKey = null;
+        if (fn && this.isPureFn(fn)) {
+            mKey = this.memoKey(stmt.name, evaluatedArgs);
+            if (mKey !== null && this.fnMemoCache.has(mKey)) {
+                return this.fnMemoCache.get(mKey);
+            }
+        }
+        const initial = this.startFunctionFrame(memoStmt, undefined);
+        if ('result' in initial) {
+            if (mKey !== null && this.fnMemoCache.size < Interpreter.MEMO_CACHE_MAX) {
+                this.fnMemoCache.set(mKey, initial.result);
+            }
             return initial.result;
+        }
         const callStack = [initial.frame];
         let finalResult = undefined;
         while (callStack.length > 0) {
@@ -1324,9 +1808,25 @@ class Interpreter {
             }
             this.dispatchRuntimeStatement(nextStmt, frame.runtimeStack);
         }
+        // ── Memoización: guardar resultado ──
+        if (mKey !== null && this.fnMemoCache.size < Interpreter.MEMO_CACHE_MAX) {
+            this.fnMemoCache.set(mKey, finalResult);
+        }
         return finalResult;
     }
     startFunctionFrame(stmt, continuation, inheritedReturnState) {
+        // ── Memoización: comprobar cache antes de crear frame ──
+        const fnDef = this.functions.get(stmt.name);
+        if (fnDef && this.isPureFn(fnDef)) {
+            const evaluatedArgs = stmt.args.map((a) => this.evaluateFormulaValue(a));
+            const mk = this.memoKey(stmt.name, evaluatedArgs);
+            if (mk !== null && this.fnMemoCache.has(mk)) {
+                return {
+                    result: this.fnMemoCache.get(mk),
+                    resultContinuation: continuation || { type: 'discard' },
+                };
+            }
+        }
         this.callDepth++;
         if (this.callDepth > MAX_CALL_DEPTH) {
             this.callDepth--;
@@ -1419,6 +1919,12 @@ class Interpreter {
         const savedReturnValue = inheritedReturnState?.value ?? this.returnValue;
         this.returnSignal = false;
         this.returnValue = undefined;
+        // Calcular clave de memoización para este frame
+        const evaluatedArgValues = Array.from(this.currentBindingFrame.bindings.values());
+        let frameMemoKey = null;
+        if (this.isPureFn(fn)) {
+            frameMemoKey = this.memoKey(name, evaluatedArgValues);
+        }
         return {
             name,
             runtimeStack: [{ kind: 'statements', statements: fn.body, index: 0 }],
@@ -1427,12 +1933,17 @@ class Interpreter {
             savedReturnValue,
             scopeSnapshot,
             continuation,
+            memoKey: frameMemoKey,
         };
     }
     finishFunctionFrame(frame) {
         const result = this.returnValue;
         this.returnSignal = frame.savedReturnSignal;
         this.returnValue = frame.savedReturnValue;
+        // ── Memoización: guardar resultado al finalizar frame ──
+        if (frame.memoKey && this.fnMemoCache.size < Interpreter.MEMO_CACHE_MAX) {
+            this.fnMemoCache.set(frame.memoKey, result);
+        }
         this.discardFunctionFrameState(frame);
         this.callDepth--;
         return result;