@stevenvo780/st-lang 4.1.0 → 4.3.0

package/dist/runtime/proof-minify/minify.js

@@ -0,0 +1,540 @@
+"use strict";
+// ============================================================
+// ST Proof Minification — Núcleo
+// ============================================================
+//
+// Transformaciones puras sobre árboles de pruebas. Ninguna operación
+// muta el input — siempre se clonan los nodos al construir el output.
+//
+// Soundness: cada regla preserva la conclusión raíz y la conformidad
+// estructural (premises siempre válidas, sin referencias colgantes).
+// El minificador NO re-checkea la prueba — asume que el input ya es
+// válido.
+//
+// Determinismo: las pasadas se aplican en orden fijo (detrivialize →
+// compact-mp → cut-elimination-local → remove-unused). El bucle
+// global termina cuando una iteración no cambia el árbol o se alcanza
+// `maxIterations`.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.countNodes = countNodes;
+exports.depthOf = depthOf;
+exports.compactModusPonensChain = compactModusPonensChain;
+exports.removeUnusedSubproofs = removeUnusedSubproofs;
+exports.minifyProof = minifyProof;
+const DEFAULT_MAX_ITERATIONS = 16;
+const ALL_RULES = [
+    'detrivialize',
+    'compact-mp',
+    'cut-elimination-local',
+    'remove-unused',
+];
+// ── Reconocedores de reglas (nombres equivalentes) ────────────
+const LEAF_RULES = new Set([
+    'axiom',
+    'ax',
+    'hypothesis',
+    'hyp',
+    'assumption',
+    'asm',
+    'premise',
+    'init',
+    'identity',
+    'id',
+]);
+const MP_RULES = new Set([
+    '→E',
+    '->E',
+    'MP',
+    'mp',
+    'modus-ponens',
+    'modus_ponens',
+    'impl-elim',
+    'implication-elimination',
+    '⊃E',
+]);
+const IMPL_INTRO_RULES = new Set(['→I', '->I', 'impl-intro', 'implication-introduction', '⊃I']);
+const AND_INTRO_RULES = new Set([
+    '∧I',
+    '&I',
+    'and-intro',
+    'conj-intro',
+    'conjunction-introduction',
+]);
+const AND_ELIM_RULES = new Set([
+    '∧E',
+    '∧E1',
+    '∧E2',
+    '&E',
+    '&E1',
+    '&E2',
+    'and-elim',
+    'and-elim1',
+    'and-elim2',
+    'conj-elim',
+    'conjunction-elimination',
+]);
+const CUT_RULES = new Set(['cut', 'Cut', 'CUT']);
+const WEAKEN_RULES = new Set(['weakening', 'weaken', 'WL', 'WR', 'exchange', 'XL', 'XR']);
+function isLeafRule(rule) {
+    return LEAF_RULES.has(rule);
+}
+function isMPRule(rule) {
+    return MP_RULES.has(rule);
+}
+function isImplIntroRule(rule) {
+    return IMPL_INTRO_RULES.has(rule);
+}
+function isAndIntroRule(rule) {
+    return AND_INTRO_RULES.has(rule);
+}
+function isAndElimRule(rule) {
+    return AND_ELIM_RULES.has(rule);
+}
+function isCutRule(rule) {
+    return CUT_RULES.has(rule);
+}
+function isWeakenRule(rule) {
+    return WEAKEN_RULES.has(rule);
+}
+// ── Utilidades de árbol ───────────────────────────────────────
+/** Normaliza una conclusión para comparación (trim + collapse ws). */
+function normalize(formula) {
+    return formula.trim().replace(/\s+/g, ' ');
+}
+function cloneNode(n) {
+    const out = {
+        conclusion: n.conclusion,
+        rule: n.rule,
+        premises: n.premises.map(cloneNode),
+    };
+    if (n.metadata !== undefined) {
+        out.metadata = { ...n.metadata };
+    }
+    return out;
+}
+/** Cuenta los nodos de un árbol (raíz incluida). */
+function countNodes(n) {
+    let total = 1;
+    for (const p of n.premises)
+        total += countNodes(p);
+    return total;
+}
+/** Profundidad máxima (raíz = 0). */
+function depthOf(n) {
+    if (n.premises.length === 0)
+        return 0;
+    let max = 0;
+    for (const p of n.premises) {
+        const d = depthOf(p);
+        if (d > max)
+            max = d;
+    }
+    return 1 + max;
+}
+/** Serialización canónica para hashing/dedup. */
+function canonicalKey(n) {
+    const kids = n.premises.map(canonicalKey).join('|');
+    return `${n.rule}::${normalize(n.conclusion)}::(${kids})`;
+}
+// ── 1. Detrivialize ───────────────────────────────────────────
+//
+// (a) Si un nodo de eliminación tiene como premisa inmediata su propio
+//     introductor con la misma conclusion final, colapsa al sub-árbol
+//     que justificó la intro. Ejemplo clásico:
+//
+//        ⌜A⌝            (∧I)
+//        ⌜B⌝   ──────────────
+//                A ∧ B
+//                (∧E1)
+//                  A
+//
+//     → simplemente la sub-prueba de A.
+//
+// (b) Dedup de premises: si dos premises directas son estructuralmente
+//     iguales, se conserva una sola copia.
+function detrivialize(node) {
+    // Primero reducimos los hijos.
+    const reducedPremises = node.premises.map(detrivialize);
+    // (a) ∧E ∘ ∧I → premisa correspondiente.
+    if (isAndElimRule(node.rule) &&
+        reducedPremises.length === 1 &&
+        isAndIntroRule(reducedPremises[0].rule) &&
+        reducedPremises[0].premises.length === 2) {
+        const intro = reducedPremises[0];
+        const target = normalize(node.conclusion);
+        // Elegir la premisa de la intro cuya conclusion coincide con la
+        // conclusion del eliminador.
+        for (const p of intro.premises) {
+            if (normalize(p.conclusion) === target) {
+                return cloneNode(p);
+            }
+        }
+    }
+    // (a') →E ∘ →I trivial: si la intro produjo A→B a partir de "asumir
+    // A, derivar B" donde B es exactamente la conclusion final y el
+    // antecedente A ya estaba como axioma/hipótesis fuera, el MP
+    // colapsa al sub-árbol que derivó B. Caso conservador: la sub-prueba
+    // de B debe ser una hoja (no re-ejecutamos sustituciones).
+    if (isMPRule(node.rule) &&
+        reducedPremises.length === 2 &&
+        isImplIntroRule(reducedPremises[0].rule) &&
+        reducedPremises[0].premises.length === 1) {
+        const intro = reducedPremises[0];
+        const body = intro.premises[0];
+        if (normalize(body.conclusion) === normalize(node.conclusion) && isLeafRule(body.rule)) {
+            return cloneNode(body);
+        }
+    }
+    // (b) Dedup de premises directas. Importante para conjunciones o
+    // pasos que repiten la misma justificación.
+    const dedupedPremises = [];
+    const seenKeys = new Set();
+    for (const p of reducedPremises) {
+        const k = canonicalKey(p);
+        if (seenKeys.has(k))
+            continue;
+        seenKeys.add(k);
+        dedupedPremises.push(p);
+    }
+    return {
+        conclusion: node.conclusion,
+        rule: node.rule,
+        premises: dedupedPremises,
+        ...(node.metadata !== undefined ? { metadata: { ...node.metadata } } : {}),
+    };
+}
+// ── 2. Compact MP chains ──────────────────────────────────────
+//
+// Una cadena de modus ponens se ve así (n = 3):
+//
+//     A     A→B
+//     ─────────  MP
+//          B           B→C
+//          ──────────────── MP
+//                   C           C→D
+//                   ─────────────── MP
+//                            D
+//
+// El minificador detecta esta estructura y produce un único nodo MP*
+// con todas las hipótesis y todas las implicaciones como premisas
+// hermanas (estructura plana), con `metadata.chain = ['A','B','C','D']`
+// y `rule = 'MP*'`.
+function compactModusPonensChain(proof) {
+    // Top-down: primero intentamos compactar EN la raíz; si compactamos
+    // recursamos en las premisas resultantes (que serán hojas de la
+    // cadena). Si no compactamos en la raíz, recursamos en cada premisa
+    // individualmente.
+    if (isMPRule(proof.rule) && proof.premises.length === 2) {
+        const compacted = tryCompactChain(proof);
+        if (compacted !== null) {
+            // Las premisas de un MP* son las implicaciones + el antecedente
+            // más profundo. Aplicamos recursión a cada una por si tienen
+            // sub-cadenas independientes.
+            return {
+                ...compacted,
+                premises: compacted.premises.map(compactModusPonensChain),
+            };
+        }
+    }
+    // No compactamos esta raíz; recursamos sobre premisas.
+    return {
+        conclusion: proof.conclusion,
+        rule: proof.rule,
+        premises: proof.premises.map(compactModusPonensChain),
+        ...(proof.metadata !== undefined ? { metadata: { ...proof.metadata } } : {}),
+    };
+}
+/**
+ * Intenta detectar una cadena de modus ponens partiendo del nodo dado.
+ * Devuelve el nodo compactado o `null` si no hay cadena de tamaño ≥ 2.
+ */
+function tryCompactChain(node) {
+    const conclusions = [];
+    const impls = [];
+    let cursor = node;
+    const visited = new Set();
+    let mpDepth = 0;
+    while (cursor && isMPRule(cursor.rule) && cursor.premises.length === 2 && !visited.has(cursor)) {
+        visited.add(cursor);
+        mpDepth++;
+        const [a, b] = cursor.premises;
+        const target = normalize(cursor.conclusion);
+        const aConc = normalize(a.conclusion);
+        const bConc = normalize(b.conclusion);
+        const isAImpl = matchesImplication(aConc, target);
+        const isBImpl = matchesImplication(bConc, target);
+        let antecedent;
+        let implication;
+        if (isAImpl && !isBImpl) {
+            implication = a;
+            antecedent = b;
+        }
+        else if (isBImpl && !isAImpl) {
+            implication = b;
+            antecedent = a;
+        }
+        else {
+            // Ambiguo o ambas son implicaciones: no compactamos esta cadena.
+            return null;
+        }
+        impls.push(implication);
+        conclusions.push(antecedent.conclusion);
+        if (isMPRule(antecedent.rule) && antecedent.premises.length === 2) {
+            cursor = antecedent;
+        }
+        else {
+            conclusions.push(cursor.conclusion);
+            impls.push(antecedent);
+            break;
+        }
+    }
+    // Sólo compactamos si hubo al menos 2 MPs encadenados.
+    if (mpDepth < 2)
+        return null;
+    return {
+        conclusion: node.conclusion,
+        rule: 'MP*',
+        premises: impls,
+        metadata: {
+            chain: conclusions,
+            compactedFrom: 'modus-ponens-chain',
+            length: conclusions.length,
+        },
+    };
+}
+/**
+ * Heurística: ¿`impl` parece ser una implicación cuyo consecuente es
+ * `target`? Reconoce los conectores `→`, `->`, `⊃`, ` implies `.
+ * NO hace parsing real — sólo string-matching del lado derecho.
+ */
+function matchesImplication(impl, target) {
+    const connectors = ['→', '->', '⊃', ' implies '];
+    for (const conn of connectors) {
+        const idx = impl.lastIndexOf(conn);
+        if (idx < 0)
+            continue;
+        let rhs = impl.slice(idx + conn.length).trim();
+        // Strip outer parens si está balanceado.
+        rhs = stripOuterParens(rhs);
+        const tgt = stripOuterParens(target);
+        if (rhs === tgt)
+            return true;
+    }
+    return false;
+}
+function stripOuterParens(s) {
+    let cur = s.trim();
+    while (cur.startsWith('(') && cur.endsWith(')')) {
+        let depth = 0;
+        let balanced = true;
+        for (let i = 0; i < cur.length; i++) {
+            const ch = cur[i];
+            if (ch === '(')
+                depth++;
+            else if (ch === ')') {
+                depth--;
+                if (depth === 0 && i < cur.length - 1) {
+                    balanced = false;
+                    break;
+                }
+            }
+        }
+        if (!balanced)
+            break;
+        cur = cur.slice(1, -1).trim();
+    }
+    return cur;
+}
+// ── 3. Local cut elimination ──────────────────────────────────
+//
+// Caso elemental: nodo `cut` con cut-formula A donde una de las dos
+// premisas es exactamente una hoja con conclusion A (la regla de
+// identidad). En ese caso el cut es trivial y se reemplaza por la
+// otra premisa, que ya derivaba la conclusion.
+function eliminateLocalCuts(node) {
+    const reducedPremises = node.premises.map(eliminateLocalCuts);
+    const next = {
+        conclusion: node.conclusion,
+        rule: node.rule,
+        premises: reducedPremises,
+        ...(node.metadata !== undefined ? { metadata: { ...node.metadata } } : {}),
+    };
+    if (!isCutRule(next.rule))
+        return next;
+    if (next.premises.length !== 2)
+        return next;
+    const [left, right] = next.premises;
+    // Si la rama izquierda es una hoja-identidad cuya conclusión coincide
+    // con la conclusión del cut, la rama derecha YA derivó la conclusión.
+    if (isLeafRule(left.rule) && normalize(left.conclusion) === normalize(next.conclusion)) {
+        return cloneNode(right);
+    }
+    if (isLeafRule(right.rule) && normalize(right.conclusion) === normalize(next.conclusion)) {
+        return cloneNode(left);
+    }
+    return next;
+}
+// ── 4. Remove unused subproofs ────────────────────────────────
+//
+// Para pasos de weakening/exchange, la(s) sub-prueba(s) que no
+// contribuyen a la conclusión del nodo padre se pueden recortar. Aquí
+// definimos "no contribuye" como: la conclusion del sub-árbol no
+// coincide con ninguna conclusion en el camino raíz→nodo, y tampoco
+// es premisa formal del nodo (caso weakening).
+//
+// Aplicación práctica: nodos weakening con N premisas donde sólo una
+// coincide con la conclusion del padre → se conservan únicamente las
+// premisas relevantes.
+function removeUnusedSubproofs(proof) {
+    const cleaned = cleanWeakenings(proof);
+    return pruneOrphanPremises(cleaned);
+}
+function cleanWeakenings(node) {
+    const reduced = node.premises.map(cleanWeakenings);
+    if (isWeakenRule(node.rule)) {
+        const target = normalize(node.conclusion);
+        // Buscamos la(s) premisa(s) que derivan exactamente la conclusion.
+        const relevant = reduced.filter((p) => containsConclusion(p, target));
+        if (relevant.length >= 1 && relevant.length < reduced.length) {
+            return {
+                conclusion: node.conclusion,
+                rule: node.rule,
+                premises: relevant,
+                ...(node.metadata !== undefined ? { metadata: { ...node.metadata } } : {}),
+            };
+        }
+        // Si todas las premisas son irrelevantes (caso degenerado): mantén
+        // sólo la primera para no perder el árbol.
+        if (relevant.length === 0 && reduced.length > 0) {
+            return {
+                conclusion: node.conclusion,
+                rule: node.rule,
+                premises: [reduced[0]],
+                ...(node.metadata !== undefined ? { metadata: { ...node.metadata } } : {}),
+            };
+        }
+    }
+    return {
+        conclusion: node.conclusion,
+        rule: node.rule,
+        premises: reduced,
+        ...(node.metadata !== undefined ? { metadata: { ...node.metadata } } : {}),
+    };
+}
+/**
+ * Recorta sub-pruebas huérfanas: una sub-prueba es huérfana si su
+ * conclusion no aparece en ninguna parte del árbol (ni como premisa
+ * referenciada, ni como conclusion intermedia útil) excepto a sí
+ * misma. Conservador: sólo opera sobre nodos con >2 premisas donde
+ * todas menos una son axiomas/hipótesis cuya conclusion nunca aparece.
+ */
+function pruneOrphanPremises(node) {
+    const reduced = node.premises.map(pruneOrphanPremises);
+    if (reduced.length <= 1) {
+        return {
+            conclusion: node.conclusion,
+            rule: node.rule,
+            premises: reduced,
+            ...(node.metadata !== undefined ? { metadata: { ...node.metadata } } : {}),
+        };
+    }
+    // Conjunto de conclusiones que aparecen en el árbol completo bajo
+    // las premisas que SÍ son no-hojas: si una hoja-hipótesis tiene
+    // conclusion que no aparece como sub-fórmula de ningún otro nodo,
+    // probablemente sea dead weight.
+    const liveConclusions = new Set();
+    for (const p of reduced) {
+        collectNonLeafConclusions(p, liveConclusions);
+    }
+    liveConclusions.add(normalize(node.conclusion));
+    // Filtramos hojas cuya conclusion no aparece como sub-string de
+    // ninguna conclusion viva. Esto es heurístico (no semántico) — sirve
+    // sólo para casos donde la hipótesis es claramente independiente.
+    const pruned = [];
+    for (const p of reduced) {
+        if (isLeafRule(p.rule) && !appearsInAnyConclusion(normalize(p.conclusion), liveConclusions)) {
+            // huérfano: no incluir.
+            continue;
+        }
+        pruned.push(p);
+    }
+    // Aseguramos al menos una premisa si node no es hoja por naturaleza.
+    if (pruned.length === 0 && reduced.length > 0) {
+        pruned.push(reduced[0]);
+    }
+    return {
+        conclusion: node.conclusion,
+        rule: node.rule,
+        premises: pruned,
+        ...(node.metadata !== undefined ? { metadata: { ...node.metadata } } : {}),
+    };
+}
+function collectNonLeafConclusions(n, set) {
+    if (!isLeafRule(n.rule)) {
+        set.add(normalize(n.conclusion));
+    }
+    for (const p of n.premises)
+        collectNonLeafConclusions(p, set);
+}
+function appearsInAnyConclusion(needle, hay) {
+    if (hay.has(needle))
+        return true;
+    for (const conc of hay) {
+        if (conc.includes(needle))
+            return true;
+    }
+    return false;
+}
+function containsConclusion(n, target) {
+    if (normalize(n.conclusion) === target)
+        return true;
+    for (const p of n.premises) {
+        if (containsConclusion(p, target))
+            return true;
+    }
+    return false;
+}
+// ── API principal ─────────────────────────────────────────────
+/**
+ * Minifica un árbol de pruebas iterando las reglas hasta punto fijo
+ * o agotar `maxIterations`.
+ */
+function minifyProof(proof, opts = {}) {
+    const maxIterations = opts.maxIterations ?? DEFAULT_MAX_ITERATIONS;
+    const rules = opts.rules ?? ALL_RULES;
+    const ruleSet = new Set(rules);
+    const originalNodes = countNodes(proof);
+    const originalDepth = depthOf(proof);
+    let current = cloneNode(proof);
+    let iterations = 0;
+    for (let i = 0; i < maxIterations; i++) {
+        iterations++;
+        const before = canonicalKey(current);
+        if (ruleSet.has('detrivialize'))
+            current = detrivialize(current);
+        if (ruleSet.has('compact-mp'))
+            current = compactModusPonensChain(current);
+        if (ruleSet.has('cut-elimination-local'))
+            current = eliminateLocalCuts(current);
+        if (ruleSet.has('remove-unused'))
+            current = removeUnusedSubproofs(current);
+        const after = canonicalKey(current);
+        if (before === after)
+            break; // punto fijo
+    }
+    const minNodes = countNodes(current);
+    const minDepth = depthOf(current);
+    const removed = originalNodes - minNodes;
+    const pct = originalNodes === 0 ? 0 : (removed / originalNodes) * 100;
+    return {
+        original: { nodes: originalNodes, depth: originalDepth },
+        minified: current,
+        reduction: {
+            nodesRemoved: removed,
+            depthDelta: originalDepth - minDepth,
+            percentage: Math.round(pct * 100) / 100,
+        },
+        iterations,
+    };
+}
+//# sourceMappingURL=minify.js.map

package/dist/runtime/proof-minify/minify.js.map

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

package/dist/runtime/proof-minify/types.d.ts

@@ -0,0 +1,89 @@
+/**
+ * Nodo genérico de un árbol de pruebas.
+ *
+ * - `conclusion`: representación textual de la fórmula derivada en el
+ *   nodo. La comparación entre conclusiones se hace por igualdad de
+ *   strings normalizados (trim + colapsar whitespace interno).
+ * - `rule`: nombre de la regla que justifica la conclusión a partir
+ *   de las premises. Convenciones reconocidas:
+ *     * `axiom`, `hypothesis`, `assumption`, `premise`: hoja sin
+ *       premises (o se ignoran las que tenga).
+ *     * `→E`, `->E`, `MP`, `modus-ponens`, `impl-elim`: eliminación
+ *       de implicación (modus ponens). Espera 2 premises: la
+ *       implicación y el antecedente.
+ *     * `→I`, `->I`, `impl-intro`: introducción de implicación.
+ *     * `∧I`, `&I`, `and-intro`, `conj-intro`: conjunción intro.
+ *     * `∧E1`, `∧E2`, `and-elim`, `conj-elim`: conjunción elim.
+ *     * `cut`: corte en sequent calculus (elimina-able localmente
+ *       cuando ambas ramas tienen el mismo cut-formula como hoja).
+ *   El resto se trata como reglas opacas (no se reducen pero sí se
+ *   detectan como redundantes/no usadas).
+ * - `premises`: subárboles. Para hojas, lista vacía.
+ * - `metadata`: opcional, free-form. Si el minificador encuentra dos
+ *   nodos idénticos por conclusión+rule, prefiere el que tenga menos
+ *   metadata (estable por orden de aparición).
+ */
+export interface GenericProofNode {
+    conclusion: string;
+    rule: string;
+    premises: GenericProofNode[];
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Reglas de reducción soportadas. El minificador las aplica en orden
+ * fijo dentro de cada iteración:
+ *
+ *   1. `detrivialize`        — quita pares intro/elim adyacentes y
+ *                              quita usos redundantes de la misma
+ *                              premisa (dedup por conclusión).
+ *   2. `compact-mp`          — colapsa cadenas A→B, A ⊢ B, B→C ⊢ C,
+ *                              C→D ⊢ D... cuando el árbol intermedio
+ *                              sólo se usa para alimentar el siguiente
+ *                              MP. La cadena queda en `metadata.chain`.
+ *   3. `cut-elimination-local` — caso simple de eliminación de cut
+ *                              cuando una rama del cut es una
+ *                              hipótesis idéntica a la otra rama.
+ *   4. `remove-unused`       — recorre el árbol y descarta sub-pruebas
+ *                              cuyo resultado nunca aparece como
+ *                              conclusion en el camino hacia la raíz
+ *                              (sólo aplica a nodos del tipo
+ *                              `weakening`/`exchange` o sub-árboles
+ *                              huérfanos en una lista de premises).
+ */
+export type MinifyRule = 'detrivialize' | 'compact-mp' | 'cut-elimination-local' | 'remove-unused';
+export interface MinifyOptions {
+    /**
+     * Tope superior de pasadas globales. Default: 16. El bucle se corta
+     * antes si una iteración entera no cambia el árbol (punto fijo).
+     */
+    maxIterations?: number;
+    /**
+     * Subconjunto de reglas a aplicar. Default: todas. El orden de
+     * aplicación dentro de una iteración es fijo independientemente del
+     * orden en este array — se respeta el orden documentado.
+     */
+    rules?: MinifyRule[];
+}
+export interface MinifyResult {
+    /** Estadísticas del árbol original. */
+    original: {
+        /** Número de nodos (incluida la raíz). */
+        nodes: number;
+        /** Profundidad máxima (raíz = 0). */
+        depth: number;
+    };
+    /** Árbol minificado. La raíz preserva la conclusion original. */
+    minified: GenericProofNode;
+    /** Métricas de reducción. */
+    reduction: {
+        /** Nodos eliminados (original.nodes - minified.nodes). */
+        nodesRemoved: number;
+        /** Diferencia de profundidad (puede ser 0 si no compactó MP). */
+        depthDelta: number;
+        /** Porcentaje de reducción de nodos, redondeado a 2 decimales. */
+        percentage: number;
+    };
+    /** Iteraciones consumidas antes del punto fijo (1-indexed). */
+    iterations: number;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/runtime/proof-minify/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/runtime/proof-minify/types.ts"],"names":[],"mappings":"AAcA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,MAAM,WAAW,gBAAgB;IAC/B,UAAU,EAAE,MAAM,CAAC;IACnB,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,gBAAgB,EAAE,CAAC;IAC7B,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACpC;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,MAAM,UAAU,GAAG,cAAc,GAAG,YAAY,GAAG,uBAAuB,GAAG,eAAe,CAAC;AAEnG,MAAM,WAAW,aAAa;IAC5B;;;OAGG;IACH,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB;;;;OAIG;IACH,KAAK,CAAC,EAAE,UAAU,EAAE,CAAC;CACtB;AAED,MAAM,WAAW,YAAY;IAC3B,uCAAuC;IACvC,QAAQ,EAAE;QACR,0CAA0C;QAC1C,KAAK,EAAE,MAAM,CAAC;QACd,qCAAqC;QACrC,KAAK,EAAE,MAAM,CAAC;KACf,CAAC;IACF,iEAAiE;IACjE,QAAQ,EAAE,gBAAgB,CAAC;IAC3B,6BAA6B;IAC7B,SAAS,EAAE;QACT,0DAA0D;QAC1D,YAAY,EAAE,MAAM,CAAC;QACrB,iEAAiE;QACjE,UAAU,EAAE,MAAM,CAAC;QACnB,kEAAkE;QAClE,UAAU,EAAE,MAAM,CAAC;KACpB,CAAC;IACF,+DAA+D;IAC/D,UAAU,EAAE,MAAM,CAAC;CACpB"}

package/dist/runtime/proof-minify/types.js

@@ -0,0 +1,16 @@
+"use strict";
+// ============================================================
+// ST Proof Minification — Tipos públicos
+// ============================================================
+//
+// Representación genérica de un árbol de prueba que sirve tanto para
+// natural deduction (intro/elim), cálculo de secuentes (G3, cut),
+// resolución, paso modus-ponens encadenado, etc. La idea es que el
+// reductor sea agnóstico al perfil lógico y opere sobre la estructura
+// `(conclusion, rule, premises)` con strings textuales.
+//
+// El minificador NO valida que la prueba sea correcta — asume que el
+// input ya es válido y se limita a aplicar transformaciones que
+// preservan la conclusión y la corrección del árbol.
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=types.js.map