@stevenvo780/st-lang 4.1.0 → 4.3.0

package/dist/runtime/term-rewriting/term-utils.d.ts

@@ -0,0 +1,64 @@
+import type { Substitution, Term } from './types';
+/**
+ * Igualdad estructural de términos (iterativa para soportar
+ * términos muy profundos sin stack overflow).
+ */
+export declare function termEquals(a: Term, b: Term): boolean;
+/**
+ * Clona un término (iterativo, soporta árboles profundos).
+ */
+export declare function cloneTerm(t: Term): Term;
+/**
+ * Conjunto de variables que aparecen en t.
+ */
+export declare function varsOf(t: Term, acc?: Set<string>): Set<string>;
+/**
+ * Aplica una sustitución a t (iterativo, soporta términos profundos).
+ *
+ * Para variables, sigue la cadena de bindings con detección de
+ * ciclos (un MGU de Robinson puede tener cadenas x → y → f(z)
+ * que sólo terminan tras varios saltos).
+ */
+export declare function applySubst(t: Term, subst: Substitution): Term;
+/**
+ * Occurs check: ¿aparece la variable v en t?
+ *
+ * Indispensable para evitar unificar x con f(x) creando términos
+ * infinitos como f(f(f(...))).
+ */
+export declare function occursIn(v: string, t: Term): boolean;
+/**
+ * Matching (pattern matching): encuentra σ tal que σ(pattern) = target.
+ *
+ * A diferencia de la unificación, solo las variables del pattern
+ * pueden ligarse. Si target contiene variables, se tratan como
+ * constantes opacas. Devuelve null si no hay match.
+ */
+export declare function match(pattern: Term, target: Term, subst?: Substitution): Substitution | null;
+/**
+ * Unificación de Robinson. Devuelve un MGU (most general unifier)
+ * o null si los términos no unifican.
+ *
+ * Implementación recursiva con occurs check.
+ */
+export declare function unify(s: Term, t: Term, subst?: Substitution): Substitution | null;
+/**
+ * Renombra todas las variables de t agregándole un sufijo (`_<suffix>`).
+ *
+ * Necesario antes de unificar dos reglas en KB completion: las variables
+ * deben ser disjuntas para que LHS₁ y LHS₂ no compartan nombres
+ * espuriamente.
+ */
+export declare function renameVars(t: Term, suffix: string): Term;
+/**
+ * Tamaño del término (número de nodos). Iterativo para evitar
+ * stack overflow en términos muy profundos.
+ */
+export declare function termSize(t: Term): number;
+/**
+ * Helpers para construir términos (azúcar para tests).
+ */
+export declare function v(name: string): Term;
+export declare function f(name: string, ...args: Term[]): Term;
+export declare function c(name: string): Term;
+//# sourceMappingURL=term-utils.d.ts.map

package/dist/runtime/term-rewriting/term-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"term-utils.d.ts","sourceRoot":"","sources":["../../../src/runtime/term-rewriting/term-utils.ts"],"names":[],"mappings":"AAgBA,OAAO,KAAK,EAAE,YAAY,EAAE,IAAI,EAAE,MAAM,SAAS,CAAC;AAElD;;;GAGG;AACH,wBAAgB,UAAU,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,IAAI,GAAG,OAAO,CAsBpD;AAED;;GAEG;AACH,wBAAgB,SAAS,CAAC,CAAC,EAAE,IAAI,GAAG,IAAI,CAEvC;AAsDD;;GAEG;AACH,wBAAgB,MAAM,CAAC,CAAC,EAAE,IAAI,EAAE,GAAG,GAAE,GAAG,CAAC,MAAM,CAAa,GAAG,GAAG,CAAC,MAAM,CAAC,CASzE;AAED;;;;;;GAMG;AACH,wBAAgB,UAAU,CAAC,CAAC,EAAE,IAAI,EAAE,KAAK,EAAE,YAAY,GAAG,IAAI,CAsD7D;AAWD;;;;;GAKG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,IAAI,GAAG,OAAO,CAYpD;AAED;;;;;;GAMG;AACH,wBAAgB,KAAK,CACnB,OAAO,EAAE,IAAI,EACb,MAAM,EAAE,IAAI,EACZ,KAAK,GAAE,YAAwB,GAC9B,YAAY,GAAG,IAAI,CA2BrB;AAED;;;;;GAKG;AACH,wBAAgB,KAAK,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,IAAI,EAAE,KAAK,GAAE,YAAwB,GAAG,YAAY,GAAG,IAAI,CA8B5F;AAiBD;;;;;;GAMG;AACH,wBAAgB,UAAU,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI,CAExD;AAED;;;GAGG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EAAE,IAAI,GAAG,MAAM,CAYxC;AAED;;GAEG;AACH,wBAAgB,CAAC,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAEpC;AAED,wBAAgB,CAAC,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,IAAI,EAAE,IAAI,EAAE,GAAG,IAAI,CAErD;AAED,wBAAgB,CAAC,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAEpC"}

package/dist/runtime/term-rewriting/term-utils.js

@@ -0,0 +1,360 @@
+"use strict";
+// ============================================================
+// ST Term Rewriting — Utilidades de términos
+// ============================================================
+//
+// Operaciones básicas sobre términos de primer orden:
+//   - igualdad estructural
+//   - sustitución
+//   - matching (un sentido) y unificación (Robinson)
+//   - occurs check
+//   - recolección de variables
+//   - clonación
+//
+// Las sustituciones son Map<string, Term>. Componer dos
+// sustituciones σ ∘ τ se hace aplicando τ a los rangos de σ
+// y uniendo: composeSubst(σ, τ).
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.termEquals = termEquals;
+exports.cloneTerm = cloneTerm;
+exports.varsOf = varsOf;
+exports.applySubst = applySubst;
+exports.occursIn = occursIn;
+exports.match = match;
+exports.unify = unify;
+exports.renameVars = renameVars;
+exports.termSize = termSize;
+exports.v = v;
+exports.f = f;
+exports.c = c;
+/**
+ * Igualdad estructural de términos (iterativa para soportar
+ * términos muy profundos sin stack overflow).
+ */
+function termEquals(a, b) {
+    const stack = [[a, b]];
+    while (stack.length > 0) {
+        const pair = stack.pop();
+        if (pair === undefined)
+            break;
+        const [x, y] = pair;
+        if (x.kind !== y.kind)
+            return false;
+        if (x.kind === 'var' && y.kind === 'var') {
+            if (x.name !== y.name)
+                return false;
+            continue;
+        }
+        if (x.kind === 'func' && y.kind === 'func') {
+            if (x.name !== y.name || x.args.length !== y.args.length)
+                return false;
+            for (let i = 0; i < x.args.length; i++) {
+                const xi = x.args[i];
+                const yi = y.args[i];
+                if (xi === undefined || yi === undefined)
+                    return false;
+                stack.push([xi, yi]);
+            }
+        }
+    }
+    return true;
+}
+/**
+ * Clona un término (iterativo, soporta árboles profundos).
+ */
+function cloneTerm(t) {
+    return mapTerm(t, (leaf) => ({ kind: 'var', name: leaf.name }));
+}
+/**
+ * Helper: map post-order iterativo sobre un término.
+ * `varMap` decide cómo transformar variables (la única transformación
+ * que necesitamos hacer top-down en los usos actuales).
+ */
+function mapTerm(t, varMap) {
+    const stack = [{ node: t, result: null, children: [] }];
+    let pending = null;
+    while (stack.length > 0) {
+        const frame = stack[stack.length - 1];
+        if (frame === undefined)
+            break;
+        if (pending !== null) {
+            frame.children.push(pending);
+            pending = null;
+        }
+        if (frame.node.kind === 'var') {
+            pending = varMap(frame.node);
+            stack.pop();
+            continue;
+        }
+        // func
+        if (frame.children.length < frame.node.args.length) {
+            const nextArg = frame.node.args[frame.children.length];
+            if (nextArg === undefined) {
+                // shouldn't happen; safeguard
+                pending = { kind: 'func', name: frame.node.name, args: frame.children };
+                stack.pop();
+                continue;
+            }
+            stack.push({ node: nextArg, result: null, children: [] });
+            continue;
+        }
+        // Todos los args procesados
+        pending = { kind: 'func', name: frame.node.name, args: frame.children };
+        stack.pop();
+    }
+    if (pending === null) {
+        throw new Error('mapTerm: unreachable — pending result is null');
+    }
+    return pending;
+}
+/**
+ * Conjunto de variables que aparecen en t.
+ */
+function varsOf(t, acc = new Set()) {
+    const stack = [t];
+    while (stack.length > 0) {
+        const node = stack.pop();
+        if (node === undefined)
+            break;
+        if (node.kind === 'var')
+            acc.add(node.name);
+        else
+            for (const a of node.args)
+                stack.push(a);
+    }
+    return acc;
+}
+/**
+ * Aplica una sustitución a t (iterativo, soporta términos profundos).
+ *
+ * Para variables, sigue la cadena de bindings con detección de
+ * ciclos (un MGU de Robinson puede tener cadenas x → y → f(z)
+ * que sólo terminan tras varios saltos).
+ */
+function applySubst(t, subst) {
+    // Implementación recursiva mediante `mapTerm`: cada variable se
+    // resuelve siguiendo la cadena; si el resultado es func, sus args
+    // también deben sustituirse — eso ya lo hace mapTerm porque las
+    // varMap devuelven Terms y cualquier subterm interno pasaría por
+    // la misma lógica. PERO mapTerm no recursa en el resultado de
+    // varMap; sólo procesa la estructura original. Para que las
+    // sustituciones en cadena se apliquen, resolvemos la cadena hasta
+    // un valor final, y sus args sub se aplican recursivamente.
+    //
+    // Como pueden ser profundos, lo hacemos en dos pasadas:
+    //   1. resolveVar(name): sigue cadena con detección de ciclos,
+    //      devuelve un Term (que puede ser otra var, una func, o el
+    //      var original si no está mapeada).
+    //   2. mapTerm con varMap = resolveVar, luego para cualquier func
+    //      resultante seguimos procesando sus args. Pero como mapTerm
+    //      ya está procesando la estructura, el resultado de varMap
+    //      no se vuelve a explorar.
+    //
+    // Solución: hacemos un fixed-point sobre el resultado final, pero
+    // sin recursión profunda — reaplicamos mapTerm hasta que la
+    // aplicación no cambie. Para términos no patológicos esto es ≤1-2
+    // pasadas.
+    const resolveVar = (leaf) => {
+        const seen = new Set();
+        let current = leaf;
+        while (current.kind === 'var') {
+            if (seen.has(current.name))
+                return current;
+            seen.add(current.name);
+            const next = subst.get(current.name);
+            if (next === undefined)
+                return current;
+            current = next;
+        }
+        return current;
+    };
+    // Aplicamos una vez: mapeo cada variable a su resolución directa
+    // (que puede ser func con vars adentro).
+    let result = mapTerm(t, resolveVar);
+    // Si la sustitución tiene cadenas (x → y donde y también está
+    // mapeada a algo), una sola pasada no basta. Iteramos con un fix-
+    // point bounded; cycle-safe gracias a `seen` en resolveVar.
+    for (let pass = 0; pass < 4; pass++) {
+        const next = mapTerm(result, resolveVar);
+        // Detección rápida: si el resultado tiene la misma raíz/estructura
+        // de aridad, asumimos estable. Para corrección estricta usamos
+        // termEquals, pero eso sería O(n) extra por pasada — mejor lo
+        // dejamos limitado a 4 pasadas que cubren prácticamente todos
+        // los casos de KB.
+        if (termEqualsShallow(next, result))
+            return next;
+        result = next;
+    }
+    return result;
+}
+/**
+ * Igualdad rápida (raíz + aridad) — usada por applySubst para
+ * decidir fixed-point sin pagar termEquals completo.
+ */
+function termEqualsShallow(a, b) {
+    if (a === b)
+        return true;
+    return termEquals(a, b);
+}
+/**
+ * Occurs check: ¿aparece la variable v en t?
+ *
+ * Indispensable para evitar unificar x con f(x) creando términos
+ * infinitos como f(f(f(...))).
+ */
+function occursIn(v, t) {
+    const stack = [t];
+    while (stack.length > 0) {
+        const node = stack.pop();
+        if (node === undefined)
+            break;
+        if (node.kind === 'var') {
+            if (node.name === v)
+                return true;
+        }
+        else {
+            for (const a of node.args)
+                stack.push(a);
+        }
+    }
+    return false;
+}
+/**
+ * Matching (pattern matching): encuentra σ tal que σ(pattern) = target.
+ *
+ * A diferencia de la unificación, solo las variables del pattern
+ * pueden ligarse. Si target contiene variables, se tratan como
+ * constantes opacas. Devuelve null si no hay match.
+ */
+function match(pattern, target, subst = new Map()) {
+    // Iterativo: stack de pares (pattern, target) que faltan unificar.
+    const sigma = new Map(subst);
+    const stack = [[pattern, target]];
+    while (stack.length > 0) {
+        const pair = stack.pop();
+        if (pair === undefined)
+            break;
+        const [p, q] = pair;
+        if (p.kind === 'var') {
+            const existing = sigma.get(p.name);
+            if (existing !== undefined) {
+                if (!termEquals(existing, q))
+                    return null;
+                continue;
+            }
+            sigma.set(p.name, q);
+            continue;
+        }
+        if (q.kind !== 'func')
+            return null;
+        if (p.name !== q.name || p.args.length !== q.args.length)
+            return null;
+        for (let i = 0; i < p.args.length; i++) {
+            const pa = p.args[i];
+            const qa = q.args[i];
+            if (pa === undefined || qa === undefined)
+                return null;
+            stack.push([pa, qa]);
+        }
+    }
+    return sigma;
+}
+/**
+ * Unificación de Robinson. Devuelve un MGU (most general unifier)
+ * o null si los términos no unifican.
+ *
+ * Implementación recursiva con occurs check.
+ */
+function unify(s, t, subst = new Map()) {
+    const sigma = new Map(subst);
+    const stack = [[s, t]];
+    while (stack.length > 0) {
+        const pair = stack.pop();
+        if (pair === undefined)
+            break;
+        const a = walk(pair[0], sigma);
+        const b = walk(pair[1], sigma);
+        if (a.kind === 'var' && b.kind === 'var' && a.name === b.name)
+            continue;
+        if (a.kind === 'var') {
+            if (occursIn(a.name, b))
+                return null;
+            sigma.set(a.name, b);
+            continue;
+        }
+        if (b.kind === 'var') {
+            if (occursIn(b.name, a))
+                return null;
+            sigma.set(b.name, a);
+            continue;
+        }
+        // Ambos func
+        if (a.name !== b.name || a.args.length !== b.args.length)
+            return null;
+        for (let i = 0; i < a.args.length; i++) {
+            const ai = a.args[i];
+            const bi = b.args[i];
+            if (ai === undefined || bi === undefined)
+                return null;
+            stack.push([ai, bi]);
+        }
+    }
+    return sigma;
+}
+/**
+ * Sigue la cadena de sustituciones para una variable, hasta llegar
+ * a un valor no-variable o a una variable libre. Evita recursión
+ * profunda durante unify.
+ */
+function walk(t, subst) {
+    let current = t;
+    while (current.kind === 'var') {
+        const next = subst.get(current.name);
+        if (next === undefined)
+            return current;
+        current = next;
+    }
+    return current;
+}
+/**
+ * Renombra todas las variables de t agregándole un sufijo (`_<suffix>`).
+ *
+ * Necesario antes de unificar dos reglas en KB completion: las variables
+ * deben ser disjuntas para que LHS₁ y LHS₂ no compartan nombres
+ * espuriamente.
+ */
+function renameVars(t, suffix) {
+    return mapTerm(t, (leaf) => ({ kind: 'var', name: `${leaf.name}_${suffix}` }));
+}
+/**
+ * Tamaño del término (número de nodos). Iterativo para evitar
+ * stack overflow en términos muy profundos.
+ */
+function termSize(t) {
+    let count = 0;
+    const stack = [t];
+    while (stack.length > 0) {
+        const node = stack.pop();
+        if (node === undefined)
+            break;
+        count++;
+        if (node.kind === 'func') {
+            for (const a of node.args)
+                stack.push(a);
+        }
+    }
+    return count;
+}
+/**
+ * Helpers para construir términos (azúcar para tests).
+ */
+function v(name) {
+    return { kind: 'var', name };
+}
+function f(name, ...args) {
+    return { kind: 'func', name, args };
+}
+function c(name) {
+    return { kind: 'func', name, args: [] };
+}
+//# sourceMappingURL=term-utils.js.map

package/dist/runtime/term-rewriting/term-utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"term-utils.js","sourceRoot":"","sources":["../../../src/runtime/term-rewriting/term-utils.ts"],"names":[],"mappings":"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"}

package/dist/runtime/term-rewriting/types.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Término de primer orden.
+ *
+ * - `var`:  variable de unificación (e.g., x, y, z).
+ * - `func`: símbolo de función con aridad implícita por len(args).
+ *           args = [] significa constante (e.g., 0, e, true).
+ */
+export type Term = {
+    kind: 'var';
+    name: string;
+} | {
+    kind: 'func';
+    name: string;
+    args: Term[];
+};
+/**
+ * Regla de reescritura l → r.
+ *
+ * Invariante: vars(r) ⊆ vars(l). Si no se cumple, normalización
+ * puede introducir variables libres y romper la lógica.
+ */
+export interface RewriteRule {
+    lhs: Term;
+    rhs: Term;
+}
+/**
+ * Term Rewriting System.
+ */
+export interface TRS {
+    rules: RewriteRule[];
+}
+/**
+ * Sustitución: mapa variable → término.
+ */
+export type Substitution = Map<string, Term>;
+/**
+ * Resultado de Knuth-Bendix completion.
+ *
+ * - `trs`:            sistema final (potencialmente extendido).
+ * - `completed`:      true si convergió (sin critical pairs unjoinables).
+ * - `criticalPairs`:  total de pares críticos examinados.
+ * - `steps`:          iteraciones del loop principal.
+ */
+export interface KBResult {
+    trs: TRS;
+    completed: boolean;
+    criticalPairs: number;
+    steps: number;
+}
+/**
+ * Opciones para Knuth-Bendix completion.
+ *
+ * - `ordering`:  estrategia para orientar nuevas ecuaciones.
+ *                Por default LPO (Lexicographic Path Order).
+ * - `maxSteps`:  cota para evitar loops infinitos cuando el sistema
+ *                no es completable (KB es semi-decidible).
+ * - `precedence`: orden parcial sobre símbolos de función
+ *                (map name → priority; mayor = mayor en el orden).
+ *                Requerido para LPO.
+ */
+export interface KBOptions {
+    ordering?: 'lpo' | 'kbo';
+    maxSteps?: number;
+    precedence?: Map<string, number>;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/runtime/term-rewriting/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/runtime/term-rewriting/types.ts"],"names":[],"mappings":"AAmBA;;;;;;GAMG;AACH,MAAM,MAAM,IAAI,GAAG;IAAE,IAAI,EAAE,KAAK,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,IAAI,EAAE,CAAA;CAAE,CAAC;AAEhG;;;;;GAKG;AACH,MAAM,WAAW,WAAW;IAC1B,GAAG,EAAE,IAAI,CAAC;IACV,GAAG,EAAE,IAAI,CAAC;CACX;AAED;;GAEG;AACH,MAAM,WAAW,GAAG;IAClB,KAAK,EAAE,WAAW,EAAE,CAAC;CACtB;AAED;;GAEG;AACH,MAAM,MAAM,YAAY,GAAG,GAAG,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;AAE7C;;;;;;;GAOG;AACH,MAAM,WAAW,QAAQ;IACvB,GAAG,EAAE,GAAG,CAAC;IACT,SAAS,EAAE,OAAO,CAAC;IACnB,aAAa,EAAE,MAAM,CAAC;IACtB,KAAK,EAAE,MAAM,CAAC;CACf;AAED;;;;;;;;;;GAUG;AACH,MAAM,WAAW,SAAS;IACxB,QAAQ,CAAC,EAAE,KAAK,GAAG,KAAK,CAAC;IACzB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,UAAU,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAClC"}

package/dist/runtime/term-rewriting/types.js

@@ -0,0 +1,21 @@
+"use strict";
+// ============================================================
+// ST Term Rewriting — Tipos públicos
+// ============================================================
+//
+// Un Term Rewriting System (TRS) es un conjunto de reglas
+//   l → r
+// donde l y r son términos de primer orden y vars(r) ⊆ vars(l).
+//
+// La reescritura aplica una regla buscando un subtérmino que
+// unifique (match) con el LHS y lo reemplaza por la sustitución
+// del RHS. Se itera hasta llegar a forma normal (sin redex
+// aplicables) o hasta saturar maxSteps.
+//
+// Aplicaciones:
+//   - Normalización en pruebas con igualdad (decision procedures).
+//   - Simplificación simbólica.
+//   - Modelado de teorías ecuacionales (grupos, anillos, listas).
+//   - Confluencia + terminación ⇒ decisión de equivalencia.
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=types.js.map

package/dist/runtime/term-rewriting/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../src/runtime/term-rewriting/types.ts"],"names":[],"mappings":";AAAA,+DAA+D;AAC/D,qCAAqC;AACrC,+DAA+D;AAC/D,EAAE;AACF,0DAA0D;AAC1D,UAAU;AACV,gEAAgE;AAChE,EAAE;AACF,6DAA6D;AAC7D,gEAAgE;AAChE,2DAA2D;AAC3D,wCAAwC;AACxC,EAAE;AACF,gBAAgB;AAChB,mEAAmE;AACnE,gCAAgC;AAChC,kEAAkE;AAClE,4DAA4D"}

package/dist/solver/cdcl-v2-incremental/index.d.ts

@@ -0,0 +1,3 @@
+export { IncrementalCDCL } from './solver';
+export type { IncrementalSolveResult, IncrementalSolverOptions, IncrementalStats, SolverSummary, } from './types';
+//# sourceMappingURL=index.d.ts.map

package/dist/solver/cdcl-v2-incremental/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/solver/cdcl-v2-incremental/index.ts"],"names":[],"mappings":"AAWA,OAAO,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC;AAC3C,YAAY,EACV,sBAAsB,EACtB,wBAAwB,EACxB,gBAAgB,EAChB,aAAa,GACd,MAAM,SAAS,CAAC"}

package/dist/solver/cdcl-v2-incremental/index.js

@@ -0,0 +1,16 @@
+"use strict";
+// CDCL incremental — entry point público.
+//
+// API:
+//   const s = new IncrementalCDCL(numVars?);
+//   s.addClause([1, -2, 3]);            // cláusulas DIMACS
+//   s.push();                            // checkpoint opcional
+//   const r = s.solve([assump1, ...]);   // sat/unsat con assumptions opcionales
+//   s.pop();                             // rollback al checkpoint
+//
+// Ver `types.ts` para los tipos de resultado.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IncrementalCDCL = void 0;
+var solver_1 = require("./solver");
+Object.defineProperty(exports, "IncrementalCDCL", { enumerable: true, get: function () { return solver_1.IncrementalCDCL; } });
+//# sourceMappingURL=index.js.map

package/dist/solver/cdcl-v2-incremental/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/solver/cdcl-v2-incremental/index.ts"],"names":[],"mappings":";AAAA,0CAA0C;AAC1C,EAAE;AACF,OAAO;AACP,6CAA6C;AAC7C,4DAA4D;AAC5D,gEAAgE;AAChE,iFAAiF;AACjF,mEAAmE;AACnE,EAAE;AACF,8CAA8C;;;AAE9C,mCAA2C;AAAlC,yGAAA,eAAe,OAAA"}

package/dist/solver/cdcl-v2-incremental/solver.d.ts

@@ -0,0 +1,83 @@
+import type { IncrementalSolveResult, IncrementalSolverOptions, SolverSummary } from './types';
+export declare class IncrementalCDCL {
+    private numVars;
+    private readonly opts;
+    private clauses;
+    private learnedFlag;
+    private learnedMeta;
+    private clauseInc;
+    private varVal;
+    private varLevel;
+    private varAnte;
+    private trail;
+    private trailLim;
+    private qHead;
+    private watches;
+    private vsids;
+    private phases;
+    private checkpoints;
+    private varToAssumption;
+    private totalDecisions;
+    private totalConflicts;
+    private totalLearned;
+    constructor(numVars?: number, options?: IncrementalSolverOptions);
+    /** Declara y devuelve una variable nueva (1-indexada). */
+    newVar(): number;
+    /** Agrega una cláusula permanente. Validación: literales !== 0 y |lit| <= numVars. */
+    addClause(literals: ReadonlyArray<number>): void;
+    /** Crea un checkpoint para rollback con `pop()`. */
+    push(): void;
+    /** Revierte hasta `levels` checkpoints atrás. Default: 1. */
+    pop(levels?: number): void;
+    /**
+     * Resuelve bajo el conjunto opcional de assumptions.
+     *
+     * Cada assumption es un literal con signo: positivo = var asumida true,
+     * negativo = var asumida false. Si el problema es UNSAT bajo esas
+     * assumptions, `failedAssumptions` contiene el subconjunto que produjo
+     * el conflicto.
+     */
+    solve(assumptions?: ReadonlyArray<number>): IncrementalSolveResult;
+    /** Devuelve la polaridad de una variable en el último modelo SAT (o undefined). */
+    modelValue(varId: number): boolean | undefined;
+    /** Limpia todo el estado, dejando 0 vars / 0 cláusulas. */
+    reset(): void;
+    /** Resumen del estado actual del solver. */
+    stats(): SolverSummary;
+    private growVarArrays;
+    private regrowHeuristics;
+    private rebuildWatches;
+    private countLearned;
+    private rollbackTo;
+    private currentLevel;
+    private litIsTrue;
+    private litIsFalse;
+    private enqueue;
+    /** Propagación booleana con watched literals. Devuelve índice de cláusula en conflicto o NO_CONFLICT. */
+    private propagate;
+    private backtrackToLevel;
+    /** Reset completo del trail incluyendo asignaciones de nivel 0. Usado entre
+     * llamadas a solve() para garantizar idempotencia. */
+    private resetAllAssignments;
+    private addLearnedClauseAt;
+    private runSolve;
+    /**
+     * Cuando un assumption `lit` está bloqueado por unit propagation desde
+     * unidades originales (sin assumptions activas), devuelve [lit] solo:
+     * ese assumption es incompatible con la base. Para v1, este es el caso
+     * trivial — sin lookup hacia atrás del antecedente.
+     */
+    private deriveCoreFromBlockedAssumption;
+    /**
+     * Dado un índice de cláusula en conflicto y la lista actual de assumptions
+     * enqueued, regresa el subconjunto de assumptions cuya negación está
+     * presente (recursivamente, vía antecedentes) en el cone de conflicto.
+     *
+     * Implementación O(|trail|): marca seen cada variable involucrada en el
+     * conflicto, recorre antecedentes hasta agotar; cualquier var marcada cuyo
+     * assumption literal sea distinto de 0 entra al core.
+     */
+    private deriveFailedAssumptions;
+    private maybeReduceLearned;
+}
+//# sourceMappingURL=solver.d.ts.map

package/dist/solver/cdcl-v2-incremental/solver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"solver.d.ts","sourceRoot":"","sources":["../../../src/solver/cdcl-v2-incremental/solver.ts"],"names":[],"mappings":"AAoCA,OAAO,KAAK,EACV,sBAAsB,EACtB,wBAAwB,EAExB,aAAa,EACd,MAAM,SAAS,CAAC;AAoBjB,qBAAa,eAAe;IAC1B,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,QAAQ,CAAC,IAAI,CAGnB;IAKF,OAAO,CAAC,OAAO,CAAoB;IACnC,OAAO,CAAC,WAAW,CAAgB;IACnC,OAAO,CAAC,WAAW,CAAkC;IACrD,OAAO,CAAC,SAAS,CAAO;IAGxB,OAAO,CAAC,MAAM,CAAY;IAC1B,OAAO,CAAC,QAAQ,CAAa;IAC7B,OAAO,CAAC,OAAO,CAAa;IAG5B,OAAO,CAAC,KAAK,CAAgB;IAC7B,OAAO,CAAC,QAAQ,CAAgB;IAChC,OAAO,CAAC,KAAK,CAAK;IAGlB,OAAO,CAAC,OAAO,CAAkB;IAGjC,OAAO,CAAC,KAAK,CAAQ;IACrB,OAAO,CAAC,MAAM,CAAa;IAG3B,OAAO,CAAC,WAAW,CAAyB;IAK5C,OAAO,CAAC,eAAe,CAAa;IAGpC,OAAO,CAAC,cAAc,CAAK;IAC3B,OAAO,CAAC,cAAc,CAAK;IAC3B,OAAO,CAAC,YAAY,CAAK;gBAEb,OAAO,SAAI,EAAE,OAAO,CAAC,EAAE,wBAAwB;IA6B3D,0DAA0D;IAC1D,MAAM,IAAI,MAAM;IAShB,sFAAsF;IACtF,SAAS,CAAC,QAAQ,EAAE,aAAa,CAAC,MAAM,CAAC,GAAG,IAAI;IAuBhD,oDAAoD;IACpD,IAAI,IAAI,IAAI;IAQZ,6DAA6D;IAC7D,GAAG,CAAC,MAAM,SAAI,GAAG,IAAI;IASrB;;;;;;;OAOG;IACH,KAAK,CAAC,WAAW,GAAE,aAAa,CAAC,MAAM,CAAM,GAAG,sBAAsB;IAetE,mFAAmF;IACnF,UAAU,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,GAAG,SAAS;IAQ9C,2DAA2D;IAC3D,KAAK,IAAI,IAAI;IAsBb,4CAA4C;IAC5C,KAAK,IAAI,aAAa;IActB,OAAO,CAAC,aAAa;IAuBrB,OAAO,CAAC,gBAAgB;IAoBxB,OAAO,CAAC,cAAc;IAetB,OAAO,CAAC,YAAY;IAMpB,OAAO,CAAC,UAAU;IA2ClB,OAAO,CAAC,YAAY;IAIpB,OAAO,CAAC,SAAS;IAIjB,OAAO,CAAC,UAAU;IAIlB,OAAO,CAAC,OAAO;IAYf,yGAAyG;IACzG,OAAO,CAAC,SAAS;IA2DjB,OAAO,CAAC,gBAAgB;IAexB;0DACsD;IACtD,OAAO,CAAC,mBAAmB;IAa3B,OAAO,CAAC,kBAAkB;IA0B1B,OAAO,CAAC,QAAQ;IA4MhB;;;;;OAKG;IACH,OAAO,CAAC,+BAA+B;IAIvC;;;;;;;;OAQG;IACH,OAAO,CAAC,uBAAuB;IAwC/B,OAAO,CAAC,kBAAkB;CA6B3B"}