@stevenvo780/st-lang 4.12.0 → 4.14.0

package/dist/reasoning/hoare-logic/index.d.ts

@@ -0,0 +1,130 @@
+export type ImpBinop = '+' | '-' | '*' | '/' | '%' | '<' | '<=' | '>' | '>=' | '==' | '!=' | '&&' | '||';
+export type ImpExpr = {
+    kind: 'const';
+    value: number;
+} | {
+    kind: 'bool';
+    value: boolean;
+} | {
+    kind: 'var';
+    name: string;
+} | {
+    kind: 'binop';
+    op: ImpBinop;
+    left: ImpExpr;
+    right: ImpExpr;
+} | {
+    kind: 'not';
+    arg: ImpExpr;
+};
+export type ImpStmt = {
+    kind: 'skip';
+} | {
+    kind: 'assign';
+    var: string;
+    expr: ImpExpr;
+} | {
+    kind: 'seq';
+    first: ImpStmt;
+    second: ImpStmt;
+} | {
+    kind: 'if';
+    cond: ImpExpr;
+    then: ImpStmt;
+    else: ImpStmt;
+} | {
+    kind: 'while';
+    cond: ImpExpr;
+    invariant?: ImpExpr;
+    body: ImpStmt;
+};
+export interface HoareTriple {
+    pre: ImpExpr;
+    stmt: ImpStmt;
+    post: ImpExpr;
+}
+export declare const num: (n: number) => ImpExpr;
+export declare const bool: (b: boolean) => ImpExpr;
+export declare const v: (name: string) => ImpExpr;
+export declare const binop: (op: ImpBinop, left: ImpExpr, right: ImpExpr) => ImpExpr;
+export declare const not: (arg: ImpExpr) => ImpExpr;
+export declare const and: (left: ImpExpr, right: ImpExpr) => ImpExpr;
+export declare const or: (left: ImpExpr, right: ImpExpr) => ImpExpr;
+export declare const eq: (left: ImpExpr, right: ImpExpr) => ImpExpr;
+export declare const lt: (left: ImpExpr, right: ImpExpr) => ImpExpr;
+export declare const le: (left: ImpExpr, right: ImpExpr) => ImpExpr;
+export declare const skip: () => ImpStmt;
+export declare const assign: (varName: string, expr: ImpExpr) => ImpStmt;
+export declare function seq(...stmts: ImpStmt[]): ImpStmt;
+export declare const ifS: (cond: ImpExpr, then_: ImpStmt, else_: ImpStmt) => ImpStmt;
+export declare const whileS: (cond: ImpExpr, body: ImpStmt, invariant?: ImpExpr) => ImpStmt;
+export declare function substitute(expr: ImpExpr, varName: string, replacement: ImpExpr): ImpExpr;
+export declare function freeVars(expr: ImpExpr, acc?: Set<string>): Set<string>;
+export declare function stmtVars(stmt: ImpStmt, acc?: Set<string>): Set<string>;
+export type State = Record<string, number>;
+export declare function evalExpr(expr: ImpExpr, state: State): number | boolean;
+export type ExecError = {
+    error: string;
+};
+export declare function execStmt(stmt: ImpStmt, state: State, maxSteps?: number): State | ExecError;
+export declare function wp(stmt: ImpStmt, post: ImpExpr): ImpExpr;
+export declare function spExtension(stmt: ImpStmt, pre: ImpExpr): ImpExpr;
+export declare function generateVCs(triple: HoareTriple): ImpExpr[];
+export interface VerificationResult {
+    valid: boolean;
+    vcs: ImpExpr[];
+    failures: Array<{
+        vc: ImpExpr;
+        state?: State;
+    }>;
+}
+export interface VerifyOptions {
+    samples?: number;
+    /** Rango de muestreo entero para variables (inclusive en ambos extremos). */
+    range?: [number, number];
+    /** Semilla determinista; si no, se usa Math.random. */
+    seed?: number;
+    /** Estados explícitos extra que el caller quiere verificar siempre. */
+    seedStates?: State[];
+}
+export declare function verifyTriple(triple: HoareTriple, opts?: VerifyOptions): VerificationResult;
+/**
+ * Swap x ↔ y vía variable temporal `t`.
+ *   t := x; x := y; y := t
+ * Tripleta canónica: {x = a ∧ y = b} swap {x = b ∧ y = a}
+ */
+export declare function programSwap(): ImpStmt;
+/**
+ * Factorial:  r := 1; k := 0; while k < n do { k := k+1; r := r * k }
+ * Tripleta:   {n = N ∧ N ≥ 0} fact {r = N!}
+ * Invariant:  k ≤ n ∧ r = k!  (codificable como r = k!, k entre 0 y n)
+ *
+ * Como la lógica de Hoare aquí no tiene factorial nativo, exponemos el
+ * código y el invariant en forma `r > 0 ∧ k ≤ n` (suficiente para
+ * los tests de mantenimiento sintácticos con muestreo: el ejecutor
+ * confirma corrección concreta para n pequeños).
+ */
+export declare function programFactorial(): ImpStmt;
+/**
+ * GCD por algoritmo de Euclides con restas:
+ *   while x != y do { if x > y then x := x - y else y := y - x }
+ * Invariant: gcd(x, y) = gcd(a, b). Como no tenemos gcd nativo,
+ * usamos como invariant `x ≥ 1 ∧ y ≥ 1` (mantenido por restas
+ * positivas cuando x ≠ y y ambos positivos al entrar).
+ */
+export declare function programGCD(): ImpStmt;
+/**
+ * Búsqueda lineal:
+ *   i := 0; found := 0;
+ *   while i < n && found == 0 do {
+ *     if a == target then found := 1 else skip;
+ *     i := i + 1
+ *   }
+ * Modelo simplificado: `a` representa el elemento actual (no un array;
+ * el AST de IMP no tiene arrays). Sirve como esqueleto pedagógico
+ * para discutir el invariant `i ≤ n` y la post `found == 1 ∨ i == n`.
+ */
+export declare function programLinearSearch(): ImpStmt;
+export declare function factorial(n: number): number;
+export declare function gcd(a: number, b: number): number;
+//# sourceMappingURL=index.d.ts.map

package/dist/reasoning/hoare-logic/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/reasoning/hoare-logic/index.ts"],"names":[],"mappings":"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"}

package/dist/reasoning/hoare-logic/index.js

@@ -0,0 +1,535 @@
+"use strict";
+// ============================================================
+// ST Hoare Logic — Verificación de programas imperativos
+// ============================================================
+//
+// Lógica de Hoare para un lenguaje IMP minimal (asignación, skip,
+// secuencia, condicional, bucle). El motor calcula precondiciones
+// más débiles (weakest precondition, wp) y postcondiciones más
+// fuertes (strongest postcondition, sp), genera condiciones de
+// verificación (VCs) y las refuta por búsqueda aleatoria sobre el
+// universo entero acotado.
+//
+// Tripleta de Hoare:
+//   {P} c {Q}  ≡  ejecutar c desde un estado que cumple P deja un
+//                estado que cumple Q (corrección parcial).
+//
+// Reglas (Hoare):
+//   skip      :  {P} skip {P}
+//   assign    :  {P[E/x]} x := E {P}
+//   seq       :  {P} c1 {R}, {R} c2 {Q}  ⊢  {P} c1; c2 {Q}
+//   if        :  {P ∧ B} c1 {Q}, {P ∧ ¬B} c2 {Q}  ⊢  {P} if B then c1 else c2 {Q}
+//   while     :  {I ∧ B} c {I}  ⊢  {I} while B do c {I ∧ ¬B}
+//   weakening :  P → P', {P'} c {Q'}, Q' → Q  ⊢  {P} c {Q}
+//
+// Para `while` exigimos invariant explícito (campo `invariant`) o
+// el VC pasa a ser trivial-falso (no podemos probar terminación
+// parcial sin invariant). Las VCs se evalúan por muestreo aleatorio
+// + estados sintéticos extraídos del programa: si alguna falla,
+// devolvemos un contramodelo.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.whileS = exports.ifS = exports.assign = exports.skip = exports.le = exports.lt = exports.eq = exports.or = exports.and = exports.not = exports.binop = exports.v = exports.bool = exports.num = void 0;
+exports.seq = seq;
+exports.substitute = substitute;
+exports.freeVars = freeVars;
+exports.stmtVars = stmtVars;
+exports.evalExpr = evalExpr;
+exports.execStmt = execStmt;
+exports.wp = wp;
+exports.spExtension = spExtension;
+exports.generateVCs = generateVCs;
+exports.verifyTriple = verifyTriple;
+exports.programSwap = programSwap;
+exports.programFactorial = programFactorial;
+exports.programGCD = programGCD;
+exports.programLinearSearch = programLinearSearch;
+exports.factorial = factorial;
+exports.gcd = gcd;
+// ── Constructores de conveniencia ────────────────────────────
+const num = (n) => ({ kind: 'const', value: n });
+exports.num = num;
+const bool = (b) => ({ kind: 'bool', value: b });
+exports.bool = bool;
+const v = (name) => ({ kind: 'var', name });
+exports.v = v;
+const binop = (op, left, right) => ({
+    kind: 'binop',
+    op,
+    left,
+    right,
+});
+exports.binop = binop;
+const not = (arg) => ({ kind: 'not', arg });
+exports.not = not;
+const and = (left, right) => (0, exports.binop)('&&', left, right);
+exports.and = and;
+const or = (left, right) => (0, exports.binop)('||', left, right);
+exports.or = or;
+const eq = (left, right) => (0, exports.binop)('==', left, right);
+exports.eq = eq;
+const lt = (left, right) => (0, exports.binop)('<', left, right);
+exports.lt = lt;
+const le = (left, right) => (0, exports.binop)('<=', left, right);
+exports.le = le;
+const skip = () => ({ kind: 'skip' });
+exports.skip = skip;
+const assign = (varName, expr) => ({
+    kind: 'assign',
+    var: varName,
+    expr,
+});
+exports.assign = assign;
+function seq(...stmts) {
+    if (stmts.length === 0)
+        return (0, exports.skip)();
+    if (stmts.length === 1)
+        return stmts[0];
+    // Foldr para mantener asociatividad derecha estable.
+    let acc = stmts[stmts.length - 1];
+    for (let i = stmts.length - 2; i >= 0; i--) {
+        acc = { kind: 'seq', first: stmts[i], second: acc };
+    }
+    return acc;
+}
+const ifS = (cond, then_, else_) => ({
+    kind: 'if',
+    cond,
+    then: then_,
+    else: else_,
+});
+exports.ifS = ifS;
+const whileS = (cond, body, invariant) => ({
+    kind: 'while',
+    cond,
+    invariant,
+    body,
+});
+exports.whileS = whileS;
+// ── Sustitución sintáctica P[E/x] ────────────────────────────
+function substitute(expr, varName, replacement) {
+    switch (expr.kind) {
+        case 'const':
+        case 'bool':
+            return expr;
+        case 'var':
+            return expr.name === varName ? replacement : expr;
+        case 'binop':
+            return {
+                kind: 'binop',
+                op: expr.op,
+                left: substitute(expr.left, varName, replacement),
+                right: substitute(expr.right, varName, replacement),
+            };
+        case 'not':
+            return { kind: 'not', arg: substitute(expr.arg, varName, replacement) };
+    }
+}
+// ── Recolección de variables libres ──────────────────────────
+function freeVars(expr, acc = new Set()) {
+    switch (expr.kind) {
+        case 'const':
+        case 'bool':
+            return acc;
+        case 'var':
+            acc.add(expr.name);
+            return acc;
+        case 'binop':
+            freeVars(expr.left, acc);
+            freeVars(expr.right, acc);
+            return acc;
+        case 'not':
+            freeVars(expr.arg, acc);
+            return acc;
+    }
+}
+function stmtVars(stmt, acc = new Set()) {
+    switch (stmt.kind) {
+        case 'skip':
+            return acc;
+        case 'assign':
+            acc.add(stmt.var);
+            freeVars(stmt.expr, acc);
+            return acc;
+        case 'seq':
+            stmtVars(stmt.first, acc);
+            stmtVars(stmt.second, acc);
+            return acc;
+        case 'if':
+            freeVars(stmt.cond, acc);
+            stmtVars(stmt.then, acc);
+            stmtVars(stmt.else, acc);
+            return acc;
+        case 'while':
+            freeVars(stmt.cond, acc);
+            if (stmt.invariant)
+                freeVars(stmt.invariant, acc);
+            stmtVars(stmt.body, acc);
+            return acc;
+    }
+}
+function evalExpr(expr, state) {
+    switch (expr.kind) {
+        case 'const':
+            return expr.value;
+        case 'bool':
+            return expr.value;
+        case 'var': {
+            const value = state[expr.name];
+            // Variables no definidas valen 0 (estado total). Esto simplifica
+            // el muestreo aleatorio y los VCs sobre programas pequeños.
+            return value === undefined ? 0 : value;
+        }
+        case 'not': {
+            const a = evalExpr(expr.arg, state);
+            return !toBool(a);
+        }
+        case 'binop': {
+            const l = evalExpr(expr.left, state);
+            const r = evalExpr(expr.right, state);
+            switch (expr.op) {
+                case '+':
+                    return toNum(l) + toNum(r);
+                case '-':
+                    return toNum(l) - toNum(r);
+                case '*':
+                    return toNum(l) * toNum(r);
+                case '/': {
+                    const rn = toNum(r);
+                    if (rn === 0)
+                        return 0; // división por cero → 0 (estado total)
+                    return Math.trunc(toNum(l) / rn);
+                }
+                case '%': {
+                    const rn = toNum(r);
+                    if (rn === 0)
+                        return 0;
+                    return toNum(l) % rn;
+                }
+                case '<':
+                    return toNum(l) < toNum(r);
+                case '<=':
+                    return toNum(l) <= toNum(r);
+                case '>':
+                    return toNum(l) > toNum(r);
+                case '>=':
+                    return toNum(l) >= toNum(r);
+                case '==':
+                    return toNum(l) === toNum(r);
+                case '!=':
+                    return toNum(l) !== toNum(r);
+                case '&&':
+                    return toBool(l) && toBool(r);
+                case '||':
+                    return toBool(l) || toBool(r);
+            }
+        }
+    }
+}
+function toNum(v) {
+    return typeof v === 'boolean' ? (v ? 1 : 0) : v;
+}
+function toBool(v) {
+    return typeof v === 'boolean' ? v : v !== 0;
+}
+function execStmt(stmt, state, maxSteps = 10_000) {
+    const counter = { steps: 0, limit: maxSteps };
+    try {
+        return execInternal(stmt, { ...state }, counter);
+    }
+    catch (err) {
+        return { error: err instanceof Error ? err.message : String(err) };
+    }
+}
+function execInternal(stmt, state, counter) {
+    if (counter.steps++ > counter.limit) {
+        throw new Error(`execStmt: límite de pasos excedido (${counter.limit})`);
+    }
+    switch (stmt.kind) {
+        case 'skip':
+            return state;
+        case 'assign': {
+            const value = evalExpr(stmt.expr, state);
+            state[stmt.var] = toNum(value);
+            return state;
+        }
+        case 'seq': {
+            execInternal(stmt.first, state, counter);
+            execInternal(stmt.second, state, counter);
+            return state;
+        }
+        case 'if': {
+            const cond = evalExpr(stmt.cond, state);
+            if (toBool(cond)) {
+                execInternal(stmt.then, state, counter);
+            }
+            else {
+                execInternal(stmt.else, state, counter);
+            }
+            return state;
+        }
+        case 'while': {
+            while (toBool(evalExpr(stmt.cond, state))) {
+                if (counter.steps++ > counter.limit) {
+                    throw new Error(`execStmt: límite de pasos excedido en while (${counter.limit})`);
+                }
+                execInternal(stmt.body, state, counter);
+            }
+            return state;
+        }
+    }
+}
+// ── Weakest precondition (wp) ────────────────────────────────
+function wp(stmt, post) {
+    switch (stmt.kind) {
+        case 'skip':
+            return post;
+        case 'assign':
+            return substitute(post, stmt.var, stmt.expr);
+        case 'seq': {
+            const after = wp(stmt.second, post);
+            return wp(stmt.first, after);
+        }
+        case 'if': {
+            const wpThen = wp(stmt.then, post);
+            const wpElse = wp(stmt.else, post);
+            // (cond → wpThen) ∧ (¬cond → wpElse)
+            return (0, exports.and)((0, exports.or)((0, exports.not)(stmt.cond), wpThen), (0, exports.or)(stmt.cond, wpElse));
+        }
+        case 'while': {
+            // Sin invariant no podemos calcular wp exacto en general.
+            // Devolvemos `false` para forzar fallo de VC explícito.
+            if (!stmt.invariant)
+                return (0, exports.bool)(false);
+            // Con invariant I la wp es simplemente I; las verificaciones
+            // adicionales (mantenimiento, salida) se generan como VCs.
+            return stmt.invariant;
+        }
+    }
+}
+// ── Strongest postcondition (sp), versión sintáctica ─────────
+//
+// Implementación pragmática: para statements sin loops devolvemos
+// una fórmula que describe el estado tras ejecutar `stmt`. Para
+// loops sin invariant cae a `true` (no informativo).
+function spExtension(stmt, pre) {
+    switch (stmt.kind) {
+        case 'skip':
+            return pre;
+        case 'assign': {
+            // Introducimos una variable fresca para el valor previo de stmt.var:
+            //   sp(P, x := E) = ∃x'. P[x'/x] ∧ x = E[x'/x]
+            // Como no soportamos cuantificadores, aproximamos por la
+            // post-substitución del valor nuevo cuando E no menciona x.
+            // Si E menciona x, devolvemos `true` (no informativo).
+            const eVars = freeVars(stmt.expr);
+            if (!eVars.has(stmt.var)) {
+                return (0, exports.and)(pre, (0, exports.eq)((0, exports.v)(stmt.var), stmt.expr));
+            }
+            return (0, exports.bool)(true);
+        }
+        case 'seq':
+            return spExtension(stmt.second, spExtension(stmt.first, pre));
+        case 'if': {
+            const spThen = spExtension(stmt.then, (0, exports.and)(pre, stmt.cond));
+            const spElse = spExtension(stmt.else, (0, exports.and)(pre, (0, exports.not)(stmt.cond)));
+            return (0, exports.or)(spThen, spElse);
+        }
+        case 'while':
+            // Saliendo de un while, vale (I ∧ ¬cond) si hay invariant.
+            if (stmt.invariant)
+                return (0, exports.and)(stmt.invariant, (0, exports.not)(stmt.cond));
+            return (0, exports.bool)(true);
+    }
+}
+// ── Generación de condiciones de verificación (VCs) ──────────
+function generateVCs(triple) {
+    const vcs = [];
+    // VC global: pre → wp(stmt, post)
+    vcs.push(implies(triple.pre, wp(triple.stmt, triple.post)));
+    collectLoopVCs(triple.stmt, triple.post, vcs);
+    return vcs;
+}
+function implies(p, q) {
+    return (0, exports.or)((0, exports.not)(p), q);
+}
+function collectLoopVCs(stmt, post, out) {
+    switch (stmt.kind) {
+        case 'skip':
+        case 'assign':
+            return;
+        case 'seq':
+            collectLoopVCs(stmt.first, wp(stmt.second, post), out);
+            collectLoopVCs(stmt.second, post, out);
+            return;
+        case 'if':
+            collectLoopVCs(stmt.then, post, out);
+            collectLoopVCs(stmt.else, post, out);
+            return;
+        case 'while': {
+            if (!stmt.invariant) {
+                // VC trivialmente falso: no hay invariant.
+                out.push((0, exports.bool)(false));
+                return;
+            }
+            const I = stmt.invariant;
+            // Mantenimiento: (I ∧ cond) → wp(body, I)
+            out.push(implies((0, exports.and)(I, stmt.cond), wp(stmt.body, I)));
+            // Salida: (I ∧ ¬cond) → post (sólo si este while es el último
+            // step antes de la post). Para keep it simple, lo generamos
+            // siempre — es una condición necesaria local en el contexto del
+            // VC global, no redundante.
+            out.push(implies((0, exports.and)(I, (0, exports.not)(stmt.cond)), post));
+            // Recurse sobre el body por loops anidados.
+            collectLoopVCs(stmt.body, I, out);
+            return;
+        }
+    }
+}
+function verifyTriple(triple, opts = {}) {
+    const samples = opts.samples ?? 200;
+    const range = opts.range ?? [-5, 10];
+    const vcs = generateVCs(triple);
+    const vars = new Set();
+    freeVars(triple.pre, vars);
+    freeVars(triple.post, vars);
+    stmtVars(triple.stmt, vars);
+    const varNames = [...vars];
+    const rand = makeRandom(opts.seed);
+    const failures = [];
+    // Determinismo: incluimos estados "corner": todos 0, todos 1, todos -1.
+    const cornerStates = [];
+    for (const c of [0, 1, -1, range[0], range[1]]) {
+        const st = {};
+        for (const name of varNames)
+            st[name] = c;
+        cornerStates.push(st);
+    }
+    const allSeed = [...cornerStates, ...(opts.seedStates ?? [])];
+    for (const vc of vcs) {
+        let counterexample;
+        // VCs literalmente `false` se reportan como fallo sintáctico sin
+        // necesidad de muestrear.
+        if (vc.kind === 'bool' && vc.value === false) {
+            failures.push({ vc });
+            continue;
+        }
+        // 1) corner + seed states
+        for (const st of allSeed) {
+            if (!evalVC(vc, st)) {
+                counterexample = st;
+                break;
+            }
+        }
+        // 2) random sampling
+        if (counterexample === undefined) {
+            for (let i = 0; i < samples; i++) {
+                const st = {};
+                for (const name of varNames) {
+                    st[name] = randIntInRange(rand, range[0], range[1]);
+                }
+                if (!evalVC(vc, st)) {
+                    counterexample = st;
+                    break;
+                }
+            }
+        }
+        if (counterexample !== undefined) {
+            failures.push({ vc, state: counterexample });
+        }
+    }
+    return { valid: failures.length === 0, vcs, failures };
+}
+function evalVC(vc, state) {
+    return toBool(evalExpr(vc, state));
+}
+function makeRandom(seed) {
+    if (seed === undefined)
+        return Math.random;
+    // Mulberry32 — pequeño PRNG determinista.
+    let s = seed >>> 0;
+    return () => {
+        s = (s + 0x6d2b79f5) >>> 0;
+        let t = s;
+        t = Math.imul(t ^ (t >>> 15), t | 1);
+        t ^= t + Math.imul(t ^ (t >>> 7), t | 61);
+        return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
+    };
+}
+function randIntInRange(rand, lo, hi) {
+    return Math.floor(rand() * (hi - lo + 1)) + lo;
+}
+// ── Programas estándar de la literatura ──────────────────────
+/**
+ * Swap x ↔ y vía variable temporal `t`.
+ *   t := x; x := y; y := t
+ * Tripleta canónica: {x = a ∧ y = b} swap {x = b ∧ y = a}
+ */
+function programSwap() {
+    return seq((0, exports.assign)('t', (0, exports.v)('x')), (0, exports.assign)('x', (0, exports.v)('y')), (0, exports.assign)('y', (0, exports.v)('t')));
+}
+/**
+ * Factorial:  r := 1; k := 0; while k < n do { k := k+1; r := r * k }
+ * Tripleta:   {n = N ∧ N ≥ 0} fact {r = N!}
+ * Invariant:  k ≤ n ∧ r = k!  (codificable como r = k!, k entre 0 y n)
+ *
+ * Como la lógica de Hoare aquí no tiene factorial nativo, exponemos el
+ * código y el invariant en forma `r > 0 ∧ k ≤ n` (suficiente para
+ * los tests de mantenimiento sintácticos con muestreo: el ejecutor
+ * confirma corrección concreta para n pequeños).
+ */
+function programFactorial() {
+    const body = seq((0, exports.assign)('k', (0, exports.binop)('+', (0, exports.v)('k'), (0, exports.num)(1))), (0, exports.assign)('r', (0, exports.binop)('*', (0, exports.v)('r'), (0, exports.v)('k'))));
+    const invariant = (0, exports.and)((0, exports.le)((0, exports.v)('k'), (0, exports.v)('n')), (0, exports.binop)('>=', (0, exports.v)('r'), (0, exports.num)(1)));
+    return seq((0, exports.assign)('r', (0, exports.num)(1)), (0, exports.assign)('k', (0, exports.num)(0)), (0, exports.whileS)((0, exports.binop)('<', (0, exports.v)('k'), (0, exports.v)('n')), body, invariant));
+}
+/**
+ * GCD por algoritmo de Euclides con restas:
+ *   while x != y do { if x > y then x := x - y else y := y - x }
+ * Invariant: gcd(x, y) = gcd(a, b). Como no tenemos gcd nativo,
+ * usamos como invariant `x ≥ 1 ∧ y ≥ 1` (mantenido por restas
+ * positivas cuando x ≠ y y ambos positivos al entrar).
+ */
+function programGCD() {
+    const body = (0, exports.ifS)((0, exports.binop)('>', (0, exports.v)('x'), (0, exports.v)('y')), (0, exports.assign)('x', (0, exports.binop)('-', (0, exports.v)('x'), (0, exports.v)('y'))), (0, exports.assign)('y', (0, exports.binop)('-', (0, exports.v)('y'), (0, exports.v)('x'))));
+    const invariant = (0, exports.and)((0, exports.binop)('>=', (0, exports.v)('x'), (0, exports.num)(1)), (0, exports.binop)('>=', (0, exports.v)('y'), (0, exports.num)(1)));
+    return (0, exports.whileS)((0, exports.binop)('!=', (0, exports.v)('x'), (0, exports.v)('y')), body, invariant);
+}
+/**
+ * Búsqueda lineal:
+ *   i := 0; found := 0;
+ *   while i < n && found == 0 do {
+ *     if a == target then found := 1 else skip;
+ *     i := i + 1
+ *   }
+ * Modelo simplificado: `a` representa el elemento actual (no un array;
+ * el AST de IMP no tiene arrays). Sirve como esqueleto pedagógico
+ * para discutir el invariant `i ≤ n` y la post `found == 1 ∨ i == n`.
+ */
+function programLinearSearch() {
+    const body = seq((0, exports.ifS)((0, exports.eq)((0, exports.v)('a'), (0, exports.v)('target')), (0, exports.assign)('found', (0, exports.num)(1)), (0, exports.skip)()), (0, exports.assign)('i', (0, exports.binop)('+', (0, exports.v)('i'), (0, exports.num)(1))));
+    const invariant = (0, exports.and)((0, exports.le)((0, exports.v)('i'), (0, exports.v)('n')), (0, exports.or)((0, exports.eq)((0, exports.v)('found'), (0, exports.num)(0)), (0, exports.eq)((0, exports.v)('found'), (0, exports.num)(1))));
+    return seq((0, exports.assign)('i', (0, exports.num)(0)), (0, exports.assign)('found', (0, exports.num)(0)), (0, exports.whileS)((0, exports.and)((0, exports.binop)('<', (0, exports.v)('i'), (0, exports.v)('n')), (0, exports.eq)((0, exports.v)('found'), (0, exports.num)(0))), body, invariant));
+}
+// ── Helper: cómputo factorial concreto (para los tests) ──────
+function factorial(n) {
+    let r = 1;
+    for (let k = 1; k <= n; k++)
+        r *= k;
+    return r;
+}
+function gcd(a, b) {
+    let x = Math.abs(a);
+    let y = Math.abs(b);
+    if (x === 0)
+        return y;
+    if (y === 0)
+        return x;
+    while (x !== y) {
+        if (x > y)
+            x -= y;
+        else
+            y -= x;
+    }
+    return x;
+}
+//# sourceMappingURL=index.js.map