@stevenvo780/st-lang 4.14.0 → 4.15.0

package/dist/logic/profiles/dl-hybrid/profile.js

@@ -0,0 +1,122 @@
+"use strict";
+// ============================================================
+// ST dL-Hybrid — Profile descriptor para registro en ST
+// ============================================================
+// Adaptador entre el AST nativo de dL (DLFormula) y la `LogicProfile`
+// del runtime ST (basada en `Formula` clásica). Por defecto, este perfil
+// se usa programáticamente con el AST nativo (parseFormula + checkValid);
+// el adaptador `LogicProfile` lo expone por el registry global pero
+// degrada graciosamente para fórmulas no-dL (no usa la forma estándar
+// de tableau modal, sino el motor dedicado de dl-hybrid).
+// ============================================================
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DLHybridProfile = void 0;
+exports.runValidity = runValidity;
+exports.runSatisfiability = runSatisfiability;
+const tableau_1 = require("./tableau");
+const ast_1 = require("./ast");
+/**
+ * Indicador para que ST sepa que este perfil usa AST nativo paralelo.
+ * Si el caller pasa una `Formula` clásica, devolvemos `unknown` con un
+ * mensaje informativo. El uso recomendado es vía las funciones exportadas
+ * en el index del perfil.
+ */
+const UNSUPPORTED_FORMULA = {
+    severity: 'info',
+    message: 'dl-hybrid usa un AST nativo (DLFormula). Para usar este perfil, parsea con `parseFormula(src)` y usa `checkValid` directamente.',
+};
+class DLHybridProfile {
+    name = 'dl-hybrid';
+    description = 'Differential Dynamic Logic (Platzer) — verificación de sistemas híbridos (estados continuos + discretos) con ODEs polinomiales lineales en subset decidible.';
+    checkWellFormed(_formula) {
+        return [UNSUPPORTED_FORMULA];
+    }
+    checkValid(formula) {
+        return this.notApplicable(formula);
+    }
+    checkSatisfiable(formula) {
+        return this.notApplicable(formula);
+    }
+    prove(goal, _theory, _premises) {
+        return this.notApplicable(goal);
+    }
+    derive(goal, _premises, _theory) {
+        return this.notApplicable(goal);
+    }
+    countermodel(formula) {
+        return this.notApplicable(formula);
+    }
+    explain(formula) {
+        return {
+            status: 'unknown',
+            output: this.explainSystem(),
+            diagnostics: [UNSUPPORTED_FORMULA],
+            formula,
+        };
+    }
+    notApplicable(formula) {
+        return {
+            status: 'unknown',
+            output: 'dl-hybrid no acepta `Formula` clásica directamente. Use el API nativo: `parseFormula`, `checkValid`, etc.',
+            diagnostics: [UNSUPPORTED_FORMULA],
+            formula,
+        };
+    }
+    explainSystem() {
+        return [
+            'Sistema: dL (Differential Dynamic Logic, Platzer 2008/2010)',
+            '  Programas híbridos:',
+            '    x := e          asignación discreta',
+            '    x := *          asignación no determinista',
+            '    ?ψ              test',
+            '    α ; β           secuencia',
+            '    α ++ β          choice no determinista (∪)',
+            '    α*              loop (acotado en la implementación)',
+            "    {x' = f(x) & Q} evolución continua bajo dominio Q",
+            '  Modalidades:',
+            '    [α] φ           todo trace de α termina en φ',
+            '    ⟨α⟩ φ           existe un trace de α que termina en φ',
+            '  Subset decidible implementado:',
+            "    - ODE x' = c (constante) → x(t) = x₀ + c·t",
+            "    - ODE x' = a·x + b lineal desacoplada → cerrada exponencial",
+            '    - Loops acotados a N iteraciones',
+            '    - Derivada de Lie disponible para invariantes diferenciales',
+            '  Aplicaciones: control, robótica, sistemas embebidos.',
+        ].join('\n');
+    }
+}
+exports.DLHybridProfile = DLHybridProfile;
+/**
+ * Adaptador: ejecuta `checkValid` sobre una DLFormula nativa y devuelve
+ * un `RunResult` ST-compatible (con witness en `output`).
+ */
+function runValidity(formula) {
+    const res = (0, tableau_1.checkValid)(formula);
+    return {
+        status: res.status === 'valid' ? 'valid' : 'invalid',
+        output: res.status === 'valid'
+            ? `${(0, ast_1.formulaToString)(formula)} es VÁLIDA en dl-hybrid (${res.statesChecked} estados muestreados)`
+            : `${(0, ast_1.formulaToString)(formula)} NO es válida (contramodelo en estado ${describeState(res.witness)})`,
+        diagnostics: [],
+    };
+}
+/** Versión satisfacibilidad. */
+function runSatisfiability(formula) {
+    const res = (0, tableau_1.checkSatisfiable)(formula);
+    return {
+        status: res.status === 'satisfiable' ? 'satisfiable' : 'unsatisfiable',
+        output: res.status === 'satisfiable'
+            ? `${(0, ast_1.formulaToString)(formula)} es SATISFACIBLE (${res.statesChecked} estados muestreados, testigo: ${describeState(res.witness)})`
+            : `${(0, ast_1.formulaToString)(formula)} es INSATISFACIBLE en la malla muestreada (${res.statesChecked} estados)`,
+        diagnostics: [],
+    };
+}
+function describeState(s) {
+    if (!s)
+        return '∅';
+    const pairs = [];
+    for (const [k, v] of s.entries())
+        pairs.push(`${k}=${v}`);
+    return `{${pairs.join(', ')}}`;
+}
+//# sourceMappingURL=profile.js.map

package/dist/logic/profiles/dl-hybrid/profile.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"profile.js","sourceRoot":"","sources":["../../../../src/logic/profiles/dl-hybrid/profile.ts"],"names":[],"mappings":"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"}

package/dist/logic/profiles/dl-hybrid/semantics.d.ts

@@ -0,0 +1,16 @@
+import type { DLTerm, DLFormula, State, CompOp } from './ast';
+/** Evalúa un término sobre un estado concreto. */
+export declare function evalTerm(t: DLTerm, s: State): number;
+/** Evalúa una comparación con tolerancia. */
+export declare function evalComp(op: CompOp, a: number, b: number): boolean;
+/**
+ * Evalúa una fórmula proposicional / aritmética (sin modalidades) sobre
+ * un estado concreto. Para fórmulas con [α]/⟨α⟩ se requiere el motor de
+ * tableau (`tableau.ts`).
+ */
+export declare function evalQuantifierFree(f: DLFormula, s: State): boolean;
+/** Substitución de un término por otro dentro de un término. */
+export declare function substTerm(t: DLTerm, varName: string, replacement: DLTerm): DLTerm;
+/** Substitución dentro de una fórmula (sólo a través de comparaciones). */
+export declare function substFormula(f: DLFormula, varName: string, replacement: DLTerm): DLFormula;
+//# sourceMappingURL=semantics.d.ts.map

package/dist/logic/profiles/dl-hybrid/semantics.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"semantics.d.ts","sourceRoot":"","sources":["../../../../src/logic/profiles/dl-hybrid/semantics.ts"],"names":[],"mappings":"AAeA,OAAO,KAAK,EAAE,MAAM,EAAE,SAAS,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,OAAO,CAAC;AAI9D,kDAAkD;AAClD,wBAAgB,QAAQ,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,KAAK,GAAG,MAAM,CAwBpD;AAED,6CAA6C;AAC7C,wBAAgB,QAAQ,CAAC,EAAE,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,OAAO,CAgBlE;AAED;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,CAAC,EAAE,SAAS,EAAE,CAAC,EAAE,KAAK,GAAG,OAAO,CAsBlE;AAED,gEAAgE;AAChE,wBAAgB,SAAS,CAAC,CAAC,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,MAAM,CAmCjF;AAED,2EAA2E;AAC3E,wBAAgB,YAAY,CAAC,CAAC,EAAE,SAAS,EAAE,OAAO,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,SAAS,CA6C1F"}

package/dist/logic/profiles/dl-hybrid/semantics.js

@@ -0,0 +1,181 @@
+"use strict";
+// ============================================================
+// ST dL-Hybrid — Semántica concreta (interpretación de términos y fórmulas)
+// ============================================================
+// Funciones puras que dan significado a términos y fórmulas dL sobre un
+// estado concreto `State = Map<varName, value: number>`. Esta capa NO
+// decide validez universal; sólo evalúa con valores concretos. La capa
+// `tableau.ts` la usa para chequear contramodelos y propagar estados a
+// través de programas híbridos.
+//
+// Convenciones:
+//   • División por cero → NaN (la comparación con NaN cae al lado false).
+//   • Comparación = sobre flotantes usa tolerancia EPS = 1e-9.
+//   • Una variable no presente en el estado se interpreta como 0.
+// ============================================================
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.evalTerm = evalTerm;
+exports.evalComp = evalComp;
+exports.evalQuantifierFree = evalQuantifierFree;
+exports.substTerm = substTerm;
+exports.substFormula = substFormula;
+const EPS = 1e-9;
+/** Evalúa un término sobre un estado concreto. */
+function evalTerm(t, s) {
+    switch (t.kind) {
+        case 'num':
+            return t.value;
+        case 'var':
+            return s.get(t.name) ?? 0;
+        case 'plus':
+            return evalTerm(t.left, s) + evalTerm(t.right, s);
+        case 'minus':
+            return evalTerm(t.left, s) - evalTerm(t.right, s);
+        case 'times':
+            return evalTerm(t.left, s) * evalTerm(t.right, s);
+        case 'div': {
+            const den = evalTerm(t.right, s);
+            if (Math.abs(den) < EPS)
+                return NaN;
+            return evalTerm(t.left, s) / den;
+        }
+        case 'neg':
+            return -evalTerm(t.arg, s);
+        case 'pow': {
+            const b = evalTerm(t.base, s);
+            return Math.pow(b, t.exp);
+        }
+    }
+}
+/** Evalúa una comparación con tolerancia. */
+function evalComp(op, a, b) {
+    if (Number.isNaN(a) || Number.isNaN(b))
+        return false;
+    switch (op) {
+        case '=':
+            return Math.abs(a - b) < EPS;
+        case '!=':
+            return Math.abs(a - b) >= EPS;
+        case '<':
+            return a < b - EPS;
+        case '<=':
+            return a <= b + EPS;
+        case '>':
+            return a > b + EPS;
+        case '>=':
+            return a >= b - EPS;
+    }
+}
+/**
+ * Evalúa una fórmula proposicional / aritmética (sin modalidades) sobre
+ * un estado concreto. Para fórmulas con [α]/⟨α⟩ se requiere el motor de
+ * tableau (`tableau.ts`).
+ */
+function evalQuantifierFree(f, s) {
+    switch (f.kind) {
+        case 'true':
+            return true;
+        case 'false':
+            return false;
+        case 'comp':
+            return evalComp(f.op, evalTerm(f.left, s), evalTerm(f.right, s));
+        case 'not':
+            return !evalQuantifierFree(f.arg, s);
+        case 'and':
+            return evalQuantifierFree(f.left, s) && evalQuantifierFree(f.right, s);
+        case 'or':
+            return evalQuantifierFree(f.left, s) || evalQuantifierFree(f.right, s);
+        case 'implies':
+            return !evalQuantifierFree(f.left, s) || evalQuantifierFree(f.right, s);
+        case 'iff':
+            return evalQuantifierFree(f.left, s) === evalQuantifierFree(f.right, s);
+        case 'box':
+        case 'diamond':
+            throw new Error('evalQuantifierFree no maneja modalidades; usar tableau.');
+    }
+}
+/** Substitución de un término por otro dentro de un término. */
+function substTerm(t, varName, replacement) {
+    switch (t.kind) {
+        case 'num':
+            return t;
+        case 'var':
+            return t.name === varName ? replacement : t;
+        case 'plus':
+            return {
+                kind: 'plus',
+                left: substTerm(t.left, varName, replacement),
+                right: substTerm(t.right, varName, replacement),
+            };
+        case 'minus':
+            return {
+                kind: 'minus',
+                left: substTerm(t.left, varName, replacement),
+                right: substTerm(t.right, varName, replacement),
+            };
+        case 'times':
+            return {
+                kind: 'times',
+                left: substTerm(t.left, varName, replacement),
+                right: substTerm(t.right, varName, replacement),
+            };
+        case 'div':
+            return {
+                kind: 'div',
+                left: substTerm(t.left, varName, replacement),
+                right: substTerm(t.right, varName, replacement),
+            };
+        case 'neg':
+            return { kind: 'neg', arg: substTerm(t.arg, varName, replacement) };
+        case 'pow':
+            return { kind: 'pow', base: substTerm(t.base, varName, replacement), exp: t.exp };
+    }
+}
+/** Substitución dentro de una fórmula (sólo a través de comparaciones). */
+function substFormula(f, varName, replacement) {
+    switch (f.kind) {
+        case 'true':
+        case 'false':
+            return f;
+        case 'comp':
+            return {
+                kind: 'comp',
+                op: f.op,
+                left: substTerm(f.left, varName, replacement),
+                right: substTerm(f.right, varName, replacement),
+            };
+        case 'not':
+            return { kind: 'not', arg: substFormula(f.arg, varName, replacement) };
+        case 'and':
+            return {
+                kind: 'and',
+                left: substFormula(f.left, varName, replacement),
+                right: substFormula(f.right, varName, replacement),
+            };
+        case 'or':
+            return {
+                kind: 'or',
+                left: substFormula(f.left, varName, replacement),
+                right: substFormula(f.right, varName, replacement),
+            };
+        case 'implies':
+            return {
+                kind: 'implies',
+                left: substFormula(f.left, varName, replacement),
+                right: substFormula(f.right, varName, replacement),
+            };
+        case 'iff':
+            return {
+                kind: 'iff',
+                left: substFormula(f.left, varName, replacement),
+                right: substFormula(f.right, varName, replacement),
+            };
+        case 'box':
+        case 'diamond':
+            // No se hace alfa-renaming: si la variable es modificada dentro del
+            // programa la substitución podría capturar; el tableau se encarga
+            // de no introducir estas situaciones (asigna desde el estado actual).
+            return f;
+    }
+}
+//# sourceMappingURL=semantics.js.map

package/dist/logic/profiles/dl-hybrid/semantics.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"semantics.js","sourceRoot":"","sources":["../../../../src/logic/profiles/dl-hybrid/semantics.ts"],"names":[],"mappings":"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"}

package/dist/logic/profiles/dl-hybrid/tableau.d.ts

@@ -0,0 +1,38 @@
+import type { DLFormula, State } from './ast';
+export interface DLOptions {
+    /** Profundidad máxima al desenrollar loops `α*`. */
+    loopUnfold?: number;
+    /** Cantidad de muestras temporales para evaluar ODEs continuas. */
+    odeSamples?: number;
+    /** Horizonte temporal máximo a explorar en ODEs. */
+    odeHorizon?: number;
+    /** Cantidad de valores muestrales para `x := *`. */
+    nondetSamples?: number[];
+    /** Estados iniciales explícitos. Si vacío, se genera una malla cubriendo las variables relevantes. */
+    initialStates?: State[];
+    /** Valores muestrales por defecto para construir la malla de iniciales. */
+    initialMesh?: number[];
+}
+/** Decisión: la fórmula es válida (vale en todo estado muestreado). */
+export interface DLCheckResult {
+    status: 'valid' | 'invalid' | 'satisfiable' | 'unsatisfiable' | 'unknown';
+    /** Contramodelo o testigo si aplica. */
+    witness?: State;
+    /** Cantidad de estados muestreados. */
+    statesChecked: number;
+}
+/**
+ * Decide si `f` es válida sobre toda la malla muestreada (criterio de
+ * validez universal acotada). Si encuentra contraejemplo lo retorna.
+ */
+export declare function checkValid(f: DLFormula, opts?: DLOptions): DLCheckResult;
+/** Decide si `f` es satisfacible en algún estado muestreado. */
+export declare function checkSatisfiable(f: DLFormula, opts?: DLOptions): DLCheckResult;
+/**
+ * Evalúa la fórmula en un estado específico — útil para casos donde el
+ * usuario quiere chequear desde una pre-condición concreta.
+ */
+export declare function evalInState(f: DLFormula, s: State, opts?: DLOptions): boolean;
+/** Re-export utilitario: lista de variables relevantes en la fórmula. */
+export declare function relevantVariables(f: DLFormula): string[];
+//# sourceMappingURL=tableau.d.ts.map

package/dist/logic/profiles/dl-hybrid/tableau.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tableau.d.ts","sourceRoot":"","sources":["../../../../src/logic/profiles/dl-hybrid/tableau.ts"],"names":[],"mappings":"AA+BA,OAAO,KAAK,EAAE,SAAS,EAAyB,KAAK,EAAE,MAAM,OAAO,CAAC;AAKrE,MAAM,WAAW,SAAS;IACxB,oDAAoD;IACpD,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,mEAAmE;IACnE,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,oDAAoD;IACpD,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,oDAAoD;IACpD,aAAa,CAAC,EAAE,MAAM,EAAE,CAAC;IACzB,sGAAsG;IACtG,aAAa,CAAC,EAAE,KAAK,EAAE,CAAC;IACxB,2EAA2E;IAC3E,WAAW,CAAC,EAAE,MAAM,EAAE,CAAC;CACxB;AA0MD,uEAAuE;AACvE,MAAM,WAAW,aAAa;IAC5B,MAAM,EAAE,OAAO,GAAG,SAAS,GAAG,aAAa,GAAG,eAAe,GAAG,SAAS,CAAC;IAC1E,wCAAwC;IACxC,OAAO,CAAC,EAAE,KAAK,CAAC;IAChB,uCAAuC;IACvC,aAAa,EAAE,MAAM,CAAC;CACvB;AAED;;;GAGG;AACH,wBAAgB,UAAU,CAAC,CAAC,EAAE,SAAS,EAAE,IAAI,CAAC,EAAE,SAAS,GAAG,aAAa,CASxE;AAED,gEAAgE;AAChE,wBAAgB,gBAAgB,CAAC,CAAC,EAAE,SAAS,EAAE,IAAI,CAAC,EAAE,SAAS,GAAG,aAAa,CAS9E;AAED;;;GAGG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAAE,SAAS,EAAE,CAAC,EAAE,KAAK,EAAE,IAAI,CAAC,EAAE,SAAS,GAAG,OAAO,CAE7E;AAED,yEAAyE;AACzE,wBAAgB,iBAAiB,CAAC,CAAC,EAAE,SAAS,GAAG,MAAM,EAAE,CAgBxD"}

package/dist/logic/profiles/dl-hybrid/tableau.js

@@ -0,0 +1,289 @@
+"use strict";
+// ============================================================
+// ST dL-Hybrid — Decision procedure tipo tableau (subset)
+// ============================================================
+// Implementación pragmática y *no* completa del cálculo de pruebas de dL.
+// La idea: en lugar de un cálculo simbólico KeYmaera-completo, modelamos
+// el espacio de estados con muestreo sobre un conjunto finito de estados
+// iniciales generados a partir de la fórmula y exploramos las posibles
+// trayectorias del programa híbrido.
+//
+// Decisión:
+//   • Para mostrar `validez universal` exigimos que NO exista un estado
+//     en el universo finito muestreado que produzca un contraejemplo.
+//   • Para `satisfiabilidad` basta con encontrar un estado donde la
+//     fórmula se cumple.
+//
+// Este enfoque cubre los ejemplos canónicos del paper de Platzer con
+// dominio acotado y se comporta como un "model-finder con horizonte
+// finito" en lugar de un decision procedure completo. Para ODEs no
+// soportadas (clasifyOde → unsupported) responde `unknown`.
+//
+// Reglas operativas para [α]φ:
+//   • [x := e] φ            → φ[e/x]  evaluado en estado actual
+//   • [x := *] φ            → ∀v . φ[v/x]  aproximado con malla
+//   • [?ψ] φ                → ψ → φ
+//   • [α; β] φ              → [α][β] φ
+//   • [α ∪ β] φ             → [α]φ ∧ [β]φ
+//   • [α*] φ                → φ ∧ [α]φ ∧ [α;α]φ ∧ … (unfold a profundidad N)
+//   • [{x'=f & Q}] φ        → ∀t≥0 . (∀s∈[0,t] . Q(x(s))) → φ(x(t))
+//                              muestreado con malla temporal.
+// ============================================================
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkValid = checkValid;
+exports.checkSatisfiable = checkSatisfiable;
+exports.evalInState = evalInState;
+exports.relevantVariables = relevantVariables;
+const ast_1 = require("./ast");
+const semantics_1 = require("./semantics");
+const differential_1 = require("./differential");
+const DEFAULTS = {
+    loopUnfold: 3,
+    odeSamples: 9,
+    odeHorizon: 5,
+    nondetSamples: [-2, -1, 0, 1, 2],
+    initialStates: [],
+    initialMesh: [-1, 0, 1, 2],
+};
+function withDefaults(opts) {
+    return { ...DEFAULTS, ...(opts ?? {}) };
+}
+/**
+ * Devuelve TODOS los estados de salida posibles tras ejecutar `prog`
+ * desde `s`. Para tests bloqueantes devuelve outcomes=[] con blocked=true.
+ * No es exhaustivo: muestrea estados.
+ */
+function executeProgram(prog, s, opts) {
+    switch (prog.kind) {
+        case 'assign': {
+            const next = (0, ast_1.cloneState)(s);
+            next.set(prog.varName, (0, semantics_1.evalTerm)(prog.rhs, s));
+            return { outcomes: [next] };
+        }
+        case 'nondet': {
+            const out = [];
+            for (const v of opts.nondetSamples) {
+                const ns = (0, ast_1.cloneState)(s);
+                ns.set(prog.varName, v);
+                out.push(ns);
+            }
+            return { outcomes: out };
+        }
+        case 'test': {
+            if ((0, semantics_1.evalQuantifierFree)(prog.cond, s))
+                return { outcomes: [s] };
+            return { outcomes: [], blocked: true };
+        }
+        case 'seq': {
+            const first = executeProgram(prog.left, s, opts);
+            const combined = [];
+            for (const mid of first.outcomes) {
+                const after = executeProgram(prog.right, mid, opts);
+                combined.push(...after.outcomes);
+            }
+            return { outcomes: combined };
+        }
+        case 'choice': {
+            const a = executeProgram(prog.left, s, opts);
+            const b = executeProgram(prog.right, s, opts);
+            return { outcomes: [...a.outcomes, ...b.outcomes] };
+        }
+        case 'loop': {
+            // Desenrolla hasta loopUnfold iteraciones; cada k es una posible salida.
+            const outcomes = [(0, ast_1.cloneState)(s)];
+            let current = [(0, ast_1.cloneState)(s)];
+            for (let k = 0; k < opts.loopUnfold; k++) {
+                const next = [];
+                for (const st of current) {
+                    const step = executeProgram(prog.body, st, opts);
+                    next.push(...step.outcomes);
+                }
+                if (next.length === 0)
+                    break;
+                outcomes.push(...next);
+                current = next;
+            }
+            return { outcomes };
+        }
+        case 'ode': {
+            const klass = (0, differential_1.classifyOde)(prog.system);
+            if (klass.kind === 'unsupported') {
+                // No podemos evaluar — devolvemos un outcome especial: el propio
+                // estado, marcando blocked si no hay dominio para verificar.
+                return { outcomes: [s], blocked: false };
+            }
+            const out = [];
+            const dt = opts.odeHorizon / Math.max(1, opts.odeSamples - 1);
+            for (let i = 0; i < opts.odeSamples; i++) {
+                const t = i * dt;
+                const ns = (0, differential_1.flow)(prog.system, s, t);
+                // Verifica dominio: si dominio falla en algún punto del segmento
+                // [0, t] descartamos. Aproximamos con malla.
+                if (prog.system.domain) {
+                    let ok = true;
+                    for (let j = 0; j <= i; j++) {
+                        const tau = j * dt;
+                        const inter = (0, differential_1.flow)(prog.system, s, tau);
+                        if (!(0, semantics_1.evalQuantifierFree)(prog.system.domain, inter)) {
+                            ok = false;
+                            break;
+                        }
+                    }
+                    if (!ok)
+                        continue;
+                }
+                out.push(ns);
+            }
+            // Siempre incluir t=0 al menos
+            if (out.length === 0)
+                out.push((0, ast_1.cloneState)(s));
+            return { outcomes: out };
+        }
+    }
+}
+/**
+ * Evalúa una fórmula dL sobre un estado concreto. Para modalidades
+ * recurre a `executeProgram`.
+ */
+function evalFormula(f, s, opts) {
+    switch (f.kind) {
+        case 'true':
+            return true;
+        case 'false':
+            return false;
+        case 'comp':
+            return (0, semantics_1.evalQuantifierFree)(f, s);
+        case 'not':
+            return !evalFormula(f.arg, s, opts);
+        case 'and':
+            return evalFormula(f.left, s, opts) && evalFormula(f.right, s, opts);
+        case 'or':
+            return evalFormula(f.left, s, opts) || evalFormula(f.right, s, opts);
+        case 'implies':
+            return !evalFormula(f.left, s, opts) || evalFormula(f.right, s, opts);
+        case 'iff':
+            return evalFormula(f.left, s, opts) === evalFormula(f.right, s, opts);
+        case 'box': {
+            const step = executeProgram(f.program, s, opts);
+            // [α]φ: en TODOS los outcomes φ debe valer.
+            // Si el test bloquea (sin outcomes), [?ψ]φ es vacuously true.
+            for (const out of step.outcomes) {
+                if (!evalFormula(f.post, out, opts))
+                    return false;
+            }
+            return true;
+        }
+        case 'diamond': {
+            const step = executeProgram(f.program, s, opts);
+            // ⟨α⟩φ: existe un outcome donde φ vale.
+            for (const out of step.outcomes) {
+                if (evalFormula(f.post, out, opts))
+                    return true;
+            }
+            return false;
+        }
+    }
+}
+/** Genera una malla de estados iniciales según las variables libres de la fórmula. */
+function generateInitialStates(f, opts) {
+    if (opts.initialStates.length > 0)
+        return opts.initialStates;
+    const vars = Array.from((0, ast_1.formulaVars)(f));
+    // También variables modificadas dentro de programas (parten de un valor inicial).
+    if (vars.length === 0)
+        return [new Map()];
+    // Producto cartesiano de la malla — limita a 4 vars máx para evitar explosión.
+    if (vars.length > 4) {
+        // Modo light: usa sólo {0, 1, -1} para cada var y limita combinaciones.
+        const mesh = [-1, 0, 1];
+        const states = [];
+        // Una muestra "todo a v" por cada v
+        for (const v of mesh) {
+            const s = new Map();
+            for (const x of vars)
+                s.set(x, v);
+            states.push(s);
+        }
+        // Una muestra mixta: variable individual con valor distinto
+        for (let i = 0; i < vars.length; i++) {
+            for (const v of mesh) {
+                const s = new Map();
+                for (let j = 0; j < vars.length; j++) {
+                    s.set(vars[j] ?? '', j === i ? v : 0);
+                }
+                states.push(s);
+            }
+        }
+        return states;
+    }
+    const mesh = opts.initialMesh;
+    const result = [];
+    const recurse = (idx, current) => {
+        if (idx === vars.length) {
+            result.push(new Map(current));
+            return;
+        }
+        const v = vars[idx];
+        if (!v)
+            return;
+        for (const val of mesh) {
+            current.set(v, val);
+            recurse(idx + 1, current);
+        }
+    };
+    recurse(0, new Map());
+    return result;
+}
+/**
+ * Decide si `f` es válida sobre toda la malla muestreada (criterio de
+ * validez universal acotada). Si encuentra contraejemplo lo retorna.
+ */
+function checkValid(f, opts) {
+    const o = withDefaults(opts);
+    const states = generateInitialStates(f, o);
+    for (const s of states) {
+        if (!evalFormula(f, s, o)) {
+            return { status: 'invalid', witness: s, statesChecked: states.length };
+        }
+    }
+    return { status: 'valid', statesChecked: states.length };
+}
+/** Decide si `f` es satisfacible en algún estado muestreado. */
+function checkSatisfiable(f, opts) {
+    const o = withDefaults(opts);
+    const states = generateInitialStates(f, o);
+    for (const s of states) {
+        if (evalFormula(f, s, o)) {
+            return { status: 'satisfiable', witness: s, statesChecked: states.length };
+        }
+    }
+    return { status: 'unsatisfiable', statesChecked: states.length };
+}
+/**
+ * Evalúa la fórmula en un estado específico — útil para casos donde el
+ * usuario quiere chequear desde una pre-condición concreta.
+ */
+function evalInState(f, s, opts) {
+    return evalFormula(f, s, withDefaults(opts));
+}
+/** Re-export utilitario: lista de variables relevantes en la fórmula. */
+function relevantVariables(f) {
+    const acc = (0, ast_1.formulaVars)(f);
+    // Incluir variables que sólo aparecen dentro de programas modales
+    const inner = (g) => {
+        if (g.kind === 'box' || g.kind === 'diamond') {
+            (0, ast_1.programVars)(g.program, acc);
+            inner(g.post);
+        }
+        else if (g.kind === 'and' || g.kind === 'or' || g.kind === 'implies' || g.kind === 'iff') {
+            inner(g.left);
+            inner(g.right);
+        }
+        else if (g.kind === 'not') {
+            inner(g.arg);
+        }
+    };
+    inner(f);
+    return Array.from(acc);
+}
+//# sourceMappingURL=tableau.js.map