@stevenvo780/st-lang 4.7.0 → 4.9.0

package/dist/reasoning/differential-privacy/index.js

@@ -0,0 +1,417 @@
+"use strict";
+// ============================================================
+// ST Differential Privacy — Primitivas y composición
+// ============================================================
+//
+// Mecanismos básicos (ε,δ)-DP con composición:
+//
+//   • Mecanismos de ruido: Laplace, Gaussian.
+//   • Mecanismo exponencial (selección bajo utility).
+//   • Randomized response (privacidad local).
+//   • Queries derivadas: count, mean, histogram.
+//   • Composición: básica, avanzada (Dwork-Rothblum-Vadhan),
+//     paralela (queries sobre dominios disjuntos).
+//   • Sensitivity calculators: global L1 y smooth (Nissim-Raskhodnikova-Smith).
+//   • PRNG inyectable y determinista por seed para tests.
+//
+// Convenciones de borde:
+//   • ε > 0 y δ ∈ [0, 1). Para δ > 0 usamos (ε,δ)-DP; el mecanismo
+//     Gaussian exige δ > 0 (ruido subgaussiano no da δ = 0).
+//   • La sensibilidad es L1 para Laplace, L2 para Gaussian.
+//   • randomized response: bit ∈ {0,1}, con probabilidad p de
+//     reportar la verdad y 1−p de flipear → ε = ln(p/(1−p)).
+//   • Composición básica es uniforme y conservadora; la avanzada
+//     usa la cota de Dwork-Rothblum-Vadhan (Theorem III.3, 2010)
+//     y sólo mejora cuando k es razonablemente grande.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeDPRng = makeDPRng;
+exports.laplaceNoise = laplaceNoise;
+exports.gaussianNoise = gaussianNoise;
+exports.exponentialMechanism = exponentialMechanism;
+exports.randomizedResponse = randomizedResponse;
+exports.randomizedResponseEpsilon = randomizedResponseEpsilon;
+exports.dpCount = dpCount;
+exports.dpMean = dpMean;
+exports.dpHistogram = dpHistogram;
+exports.basicComposition = basicComposition;
+exports.advancedComposition = advancedComposition;
+exports.parallelComposition = parallelComposition;
+exports.globalSensitivityL1 = globalSensitivityL1;
+exports.smoothSensitivity = smoothSensitivity;
+// Mulberry32 — PRNG de 32 bits, sencillo y determinista, suficiente
+// para tests reproducibles. NO criptográfico: nunca usar para
+// despliegues reales de DP.
+function mulberry32(seed) {
+    let a = seed | 0;
+    return () => {
+        a = (a + 0x6d2b79f5) | 0;
+        let t = a;
+        t = Math.imul(t ^ (t >>> 15), t | 1);
+        t ^= t + Math.imul(t ^ (t >>> 7), t | 61);
+        return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
+    };
+}
+// Construye un DPRng a partir de un seed (default: Math.random como
+// arranque, equivalente a no-determinista). Para reproducibilidad
+// pasar siempre un seed entero.
+function makeDPRng(seed) {
+    const u = seed === undefined ? Math.random : mulberry32(seed >>> 0);
+    return {
+        uniform: () => u(),
+        laplace: (b) => {
+            // Inverse-CDF: si U ~ Uniform(-1/2, 1/2), entonces
+            // X = -b · sign(U) · ln(1 − 2|U|) ~ Laplace(0, b).
+            const r = u() - 0.5;
+            const sign = r < 0 ? -1 : 1;
+            // Clamp para evitar log(0). El factor 1 − 2|U| ∈ (0, 1].
+            const x = 1 - 2 * Math.abs(r);
+            return -b * sign * Math.log(x === 0 ? Number.MIN_VALUE : x);
+        },
+        gaussian: (mu, sigma) => {
+            // Box-Muller con dos uniformes independientes.
+            let u1 = u();
+            // Evitar log(0).
+            if (u1 === 0)
+                u1 = Number.MIN_VALUE;
+            const u2 = u();
+            const r = Math.sqrt(-2 * Math.log(u1));
+            const theta = 2 * Math.PI * u2;
+            return mu + sigma * r * Math.cos(theta);
+        },
+    };
+}
+// RNG por defecto (no determinista) reutilizado por todas las funciones
+// públicas que no reciben un rng explícito.
+const DEFAULT_RNG = makeDPRng();
+// ------------------------------------------------------------
+// Validación de parámetros
+// ------------------------------------------------------------
+function assertEpsilon(epsilon) {
+    if (!Number.isFinite(epsilon) || epsilon <= 0) {
+        throw new Error(`differential-privacy: epsilon debe ser finito y > 0 (got ${epsilon})`);
+    }
+}
+function assertDelta(delta) {
+    if (!Number.isFinite(delta) || delta < 0 || delta >= 1) {
+        throw new Error(`differential-privacy: delta debe estar en [0, 1) (got ${delta})`);
+    }
+}
+function assertSensitivity(sensitivity) {
+    if (!Number.isFinite(sensitivity) || sensitivity < 0) {
+        throw new Error(`differential-privacy: sensitivity debe ser finita y ≥ 0 (got ${sensitivity})`);
+    }
+}
+// ------------------------------------------------------------
+// Mecanismos de ruido
+// ------------------------------------------------------------
+/**
+ * Mecanismo de Laplace: agrega ruido Laplace(0, Δ/ε) a `value`.
+ * Da ε-DP puro (δ = 0) cuando Δ es la sensibilidad L1 de la query.
+ */
+function laplaceNoise(value, sensitivity, epsilon, rng = DEFAULT_RNG) {
+    assertEpsilon(epsilon);
+    assertSensitivity(sensitivity);
+    if (sensitivity === 0)
+        return value;
+    const b = sensitivity / epsilon;
+    return value + rng.laplace(b);
+}
+/**
+ * Mecanismo Gaussian: agrega N(0, σ²) con σ = Δ·√(2 ln(1.25/δ))/ε,
+ * la calibración estándar de Dwork-Roth (Algorithmic Foundations,
+ * Theorem A.1). Garantiza (ε,δ)-DP para ε ∈ (0, 1] cuando Δ es la
+ * sensibilidad L2. Para ε > 1 la cota sigue siendo válida pero deja
+ * de ser tight; los frameworks modernos prefieren la "analytic
+ * Gaussian" (Balle-Wang 2018) — la dejamos para una iteración futura.
+ */
+function gaussianNoise(value, sensitivity, epsilon, delta, rng = DEFAULT_RNG) {
+    assertEpsilon(epsilon);
+    assertDelta(delta);
+    assertSensitivity(sensitivity);
+    if (delta === 0) {
+        throw new Error('gaussianNoise: requiere delta > 0 (ε,δ)-DP');
+    }
+    if (sensitivity === 0)
+        return value;
+    const sigma = (sensitivity * Math.sqrt(2 * Math.log(1.25 / delta))) / epsilon;
+    return value + rng.gaussian(0, sigma);
+}
+/**
+ * Mecanismo exponencial: elige un item con probabilidad proporcional
+ * a exp(ε · score(item) / (2 · sensitivity)). Implementa la
+ * formulación canónica (McSherry-Talwar 2007). Da ε-DP cuando
+ * `sensitivity` es la sensibilidad de la función de score.
+ */
+function exponentialMechanism(items, score, sensitivity, epsilon, rng = DEFAULT_RNG) {
+    assertEpsilon(epsilon);
+    assertSensitivity(sensitivity);
+    if (items.length === 0) {
+        throw new Error('exponentialMechanism: items vacío');
+    }
+    if (sensitivity === 0) {
+        // Determinista: máximo argmax estricto.
+        let best = items[0];
+        let bestScore = score(best);
+        for (let i = 1; i < items.length; i++) {
+            const cand = items[i];
+            const s = score(cand);
+            if (s > bestScore) {
+                bestScore = s;
+                best = cand;
+            }
+        }
+        return best;
+    }
+    const scores = items.map((it) => score(it));
+    // Estabilización numérica: restar el máximo antes de exponenciar.
+    let maxScore = -Infinity;
+    for (const s of scores) {
+        if (s > maxScore)
+            maxScore = s;
+    }
+    const weights = scores.map((s) => Math.exp((epsilon * (s - maxScore)) / (2 * sensitivity)));
+    let total = 0;
+    for (const w of weights)
+        total += w;
+    if (!Number.isFinite(total) || total <= 0) {
+        throw new Error('exponentialMechanism: pesos no normalizables');
+    }
+    const u = rng.uniform() * total;
+    let acc = 0;
+    for (let i = 0; i < items.length; i++) {
+        acc += weights[i];
+        if (u < acc)
+            return items[i];
+    }
+    return items[items.length - 1];
+}
+/**
+ * Randomized response binario: reporta `bit` con probabilidad `p`,
+ * y `¬bit` con probabilidad 1 − p. Garantiza ε-DP local con
+ * ε = |ln(p / (1 − p))|. La elección clásica p = 3/4 da ε = ln 3.
+ */
+function randomizedResponse(bit, p, rng = DEFAULT_RNG) {
+    if (!Number.isFinite(p) || p <= 0 || p >= 1) {
+        throw new Error(`randomizedResponse: p debe estar en (0, 1) (got ${p})`);
+    }
+    return rng.uniform() < p ? bit : !bit;
+}
+/**
+ * ε equivalente a un mecanismo de randomized response con
+ * probabilidad de verdad `p`. Útil para test del trade-off.
+ */
+function randomizedResponseEpsilon(p) {
+    if (!Number.isFinite(p) || p <= 0 || p >= 1) {
+        throw new Error(`randomizedResponseEpsilon: p debe estar en (0, 1) (got ${p})`);
+    }
+    return Math.abs(Math.log(p / (1 - p)));
+}
+// ------------------------------------------------------------
+// Queries derivadas
+// ------------------------------------------------------------
+/**
+ * Conteo DP: cuenta cuántos valores cumplen `predicate` y aplica
+ * ruido Laplace con sensibilidad 1 (cambiar un registro mueve el
+ * conteo en a lo más 1). El resultado se redondea al entero más
+ * cercano y se clamp-a a ≥ 0 (un conteo nunca es negativo).
+ */
+function dpCount(values, predicate, epsilon, rng = DEFAULT_RNG) {
+    assertEpsilon(epsilon);
+    let count = 0;
+    for (const v of values) {
+        if (predicate(v))
+            count++;
+    }
+    const noisy = laplaceNoise(count, 1, epsilon, rng);
+    return Math.max(0, Math.round(noisy));
+}
+/**
+ * Media DP de valores acotados al rango [low, high]: clipea cada
+ * valor al rango, calcula la media empírica y aplica Laplace con
+ * sensibilidad (high − low) / n. Asumimos n público.
+ */
+function dpMean(values, range, epsilon, rng = DEFAULT_RNG) {
+    assertEpsilon(epsilon);
+    const [low, high] = range;
+    if (!Number.isFinite(low) || !Number.isFinite(high) || high <= low) {
+        throw new Error(`dpMean: rango inválido [${low}, ${high}]`);
+    }
+    if (values.length === 0) {
+        throw new Error('dpMean: values vacío');
+    }
+    const n = values.length;
+    let sum = 0;
+    for (const v of values) {
+        const clipped = v < low ? low : v > high ? high : v;
+        sum += clipped;
+    }
+    const mean = sum / n;
+    const sensitivity = (high - low) / n;
+    return laplaceNoise(mean, sensitivity, epsilon, rng);
+}
+/**
+ * Histograma DP sobre `categories`: cuenta ocurrencias por categoría
+ * y agrega ruido Laplace independiente a cada bin con sensibilidad 1.
+ * Asumimos que cada registro pertenece a a lo más una categoría
+ * (cambiar un registro mueve a lo más un bin en ±1). Si las
+ * categorías son disjuntas y cubrentes, este es un caso clásico de
+ * composición paralela: el ε total = ε.
+ */
+function dpHistogram(values, categories, epsilon, rng = DEFAULT_RNG) {
+    assertEpsilon(epsilon);
+    const counts = new Map();
+    for (const c of categories)
+        counts.set(c, 0);
+    for (const v of values) {
+        const cur = counts.get(v);
+        if (cur !== undefined)
+            counts.set(v, cur + 1);
+    }
+    const out = new Map();
+    for (const [cat, cnt] of counts) {
+        const noisy = laplaceNoise(cnt, 1, epsilon, rng);
+        out.set(cat, Math.max(0, Math.round(noisy)));
+    }
+    return out;
+}
+/**
+ * Composición básica (Dwork-McSherry-Nissim-Smith 2006, Theorem 3.16
+ * en Algorithmic Foundations): la composición secuencial de k
+ * mecanismos (ε_i, δ_i)-DP da (Σ ε_i, Σ δ_i)-DP. Cota uniforme y
+ * conservadora.
+ */
+function basicComposition(mechanisms) {
+    let epsilon = 0;
+    let delta = 0;
+    for (const m of mechanisms) {
+        assertEpsilon(m.epsilon);
+        assertDelta(m.delta);
+        epsilon += m.epsilon;
+        delta += m.delta;
+    }
+    return { epsilon, delta };
+}
+/**
+ * Composición avanzada (Dwork-Rothblum-Vadhan 2010, Theorem III.3):
+ * para k mecanismos cada uno (ε, δ)-DP, el compuesto es
+ *
+ *   (√(2 k ln(1/δ')) · ε  +  k · ε · (e^ε − 1),  k δ + δ')-DP
+ *
+ * para cualquier δ' > 0. Cuando los ε_i son heterogéneos usamos el
+ * máximo como cota uniforme (válida pero no óptima; el tight bound
+ * heterogéneo requiere RDP/zCDP, fuera del alcance de este módulo).
+ *
+ * `deltaTotal` es el δ' adicional que el caller acepta pagar.
+ * Devuelve el (ε,δ) total cubriendo el slack δ'.
+ */
+function advancedComposition(mechanisms, deltaTotal) {
+    if (mechanisms.length === 0) {
+        return { epsilon: 0, delta: deltaTotal };
+    }
+    assertDelta(deltaTotal);
+    if (deltaTotal <= 0) {
+        throw new Error('advancedComposition: deltaTotal debe ser > 0');
+    }
+    let maxEps = 0;
+    let sumDelta = 0;
+    for (const m of mechanisms) {
+        assertEpsilon(m.epsilon);
+        assertDelta(m.delta);
+        if (m.epsilon > maxEps)
+            maxEps = m.epsilon;
+        sumDelta += m.delta;
+    }
+    const k = mechanisms.length;
+    const eps = maxEps;
+    const epsilonComposed = Math.sqrt(2 * k * Math.log(1 / deltaTotal)) * eps + k * eps * (Math.exp(eps) - 1);
+    return { epsilon: epsilonComposed, delta: sumDelta + deltaTotal };
+}
+/**
+ * Composición paralela: cuando k mecanismos actúan sobre particiones
+ * disjuntas del dataset, el ε total es el máximo (no la suma), y el
+ * δ total es el máximo (no la suma). Caso clásico: histograma con
+ * categorías mutuamente excluyentes.
+ */
+function parallelComposition(mechanisms) {
+    let maxEps = 0;
+    let maxDelta = 0;
+    for (const m of mechanisms) {
+        assertEpsilon(m.epsilon);
+        assertDelta(m.delta);
+        if (m.epsilon > maxEps)
+            maxEps = m.epsilon;
+        if (m.delta > maxDelta)
+            maxDelta = m.delta;
+    }
+    return { epsilon: maxEps, delta: maxDelta };
+}
+// ------------------------------------------------------------
+// Sensitivity calculators
+// ------------------------------------------------------------
+/**
+ * Sensibilidad global L1: el máximo de |f(D) − f(D')| sobre la
+ * lista de pares neighbours suministrada. Implementación empírica
+ * pensada para tests/diagnóstico — la sensibilidad real exige
+ * razonar sobre todas las parejas válidas, no sólo las muestreadas.
+ */
+function globalSensitivityL1(fn, neighbors) {
+    let max = 0;
+    for (const [a, b] of neighbors) {
+        const diff = Math.abs(fn(a) - fn(b));
+        if (diff > max)
+            max = diff;
+    }
+    return max;
+}
+/**
+ * Sensibilidad suave (Nissim-Raskhodnikova-Smith 2007):
+ *
+ *   S*_β(f, D) = max_k e^{−β·k} · LS^{(k)}(f, D)
+ *
+ * donde LS^{(k)} es la sensibilidad local a distancia k. Aproximamos
+ * variando vecinos hasta `data.length` (cota superior de k). Para
+ * datasets grandes, restringir el k máximo via la longitud del
+ * propio dataset.
+ *
+ * Esta es una versión basada en mutaciones simples (cambiar un valor
+ * por el mín o máx empírico) — suficiente para median/mean acotados
+ * en tests, no un cálculo general.
+ */
+function smoothSensitivity(fn, data, beta) {
+    if (!Number.isFinite(beta) || beta <= 0) {
+        throw new Error(`smoothSensitivity: beta debe ser > 0 (got ${beta})`);
+    }
+    if (data.length === 0)
+        return 0;
+    // Determinar rango empírico para sintetizar vecinos extremos.
+    let lo = data[0];
+    let hi = data[0];
+    for (const v of data) {
+        if (v < lo)
+            lo = v;
+        if (v > hi)
+            hi = v;
+    }
+    const base = fn(data);
+    let max = 0;
+    // Para cada k = 0..n, calculamos LS^{(k)} aproximada cambiando los
+    // primeros k valores a `lo` o `hi` (el extremo que más mueve la query).
+    for (let k = 0; k <= data.length; k++) {
+        // Vecinos a distancia k: probar mutar k posiciones a lo o hi.
+        // Esto es heurístico — para mediana/media acotadas es exacto.
+        const mutLo = data.slice();
+        const mutHi = data.slice();
+        for (let i = 0; i < k; i++) {
+            mutLo[i] = lo;
+            mutHi[i] = hi;
+        }
+        const dLo = Math.abs(fn(mutLo) - base);
+        const dHi = Math.abs(fn(mutHi) - base);
+        const lsK = Math.max(dLo, dHi);
+        const smoothed = Math.exp(-beta * k) * lsK;
+        if (smoothed > max)
+            max = smoothed;
+    }
+    return max;
+}
+//# sourceMappingURL=index.js.map

package/dist/reasoning/differential-privacy/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/reasoning/differential-privacy/index.ts"],"names":[],"mappings":";AAAA,+DAA+D;AAC/D,qDAAqD;AACrD,+DAA+D;AAC/D,EAAE;AACF,+CAA+C;AAC/C,EAAE;AACF,8CAA8C;AAC9C,sDAAsD;AACtD,8CAA8C;AAC9C,iDAAiD;AACjD,6DAA6D;AAC7D,mDAAmD;AACnD,gFAAgF;AAChF,0DAA0D;AAC1D,EAAE;AACF,yBAAyB;AACzB,mEAAmE;AACnE,6DAA6D;AAC7D,4DAA4D;AAC5D,8DAA8D;AAC9D,6DAA6D;AAC7D,iEAAiE;AACjE,iEAAiE;AACjE,uDAAuD;;AA+CvD,8BAwBC;AAoCD,oCAWC;AAUD,sCAgBC;AAQD,oDA6CC;AAOD,gDAKC;AAMD,8DAKC;AAYD,0BAaC;AAOD,wBAuBC;AAUD,kCAmBC;AAiBD,4CAUC;AAeD,kDAwBC;AAQD,kDAUC;AAYD,kDAUC;AAgBD,8CAoCC;AAhbD,oEAAoE;AACpE,8DAA8D;AAC9D,4BAA4B;AAC5B,SAAS,UAAU,CAAC,IAAY;IAC9B,IAAI,CAAC,GAAG,IAAI,GAAG,CAAC,CAAC;IACjB,OAAO,GAAG,EAAE;QACV,CAAC,GAAG,CAAC,CAAC,GAAG,UAAU,CAAC,GAAG,CAAC,CAAC;QACzB,IAAI,CAAC,GAAG,CAAC,CAAC;QACV,CAAC,GAAG,IAAI,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;QACrC,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,GAAG,EAAE,CAAC,CAAC;QAC1C,OAAO,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,GAAG,UAAU,CAAC;IAC/C,CAAC,CAAC;AACJ,CAAC;AAED,oEAAoE;AACpE,kEAAkE;AAClE,gCAAgC;AAChC,SAAgB,SAAS,CAAC,IAAa;IACrC,MAAM,CAAC,GAAG,IAAI,KAAK,SAAS,CAAC,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,UAAU,CAAC,IAAI,KAAK,CAAC,CAAC,CAAC;IACpE,OAAO;QACL,OAAO,EAAE,GAAG,EAAE,CAAC,CAAC,EAAE;QAClB,OAAO,EAAE,CAAC,CAAS,EAAE,EAAE;YACrB,mDAAmD;YACnD,mDAAmD;YACnD,MAAM,CAAC,GAAG,CAAC,EAAE,GAAG,GAAG,CAAC;YACpB,MAAM,IAAI,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;YAC5B,yDAAyD;YACzD,MAAM,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;YAC9B,OAAO,CAAC,CAAC,GAAG,IAAI,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;QAC9D,CAAC;QACD,QAAQ,EAAE,CAAC,EAAU,EAAE,KAAa,EAAE,EAAE;YACtC,+CAA+C;YAC/C,IAAI,EAAE,GAAG,CAAC,EAAE,CAAC;YACb,iBAAiB;YACjB,IAAI,EAAE,KAAK,CAAC;gBAAE,EAAE,GAAG,MAAM,CAAC,SAAS,CAAC;YACpC,MAAM,EAAE,GAAG,CAAC,EAAE,CAAC;YACf,MAAM,CAAC,GAAG,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC,CAAC;YACvC,MAAM,KAAK,GAAG,CAAC,GAAG,IAAI,CAAC,EAAE,GAAG,EAAE,CAAC;YAC/B,OAAO,EAAE,GAAG,KAAK,GAAG,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;QAC1C,CAAC;KACF,CAAC;AACJ,CAAC;AAED,wEAAwE;AACxE,4CAA4C;AAC5C,MAAM,WAAW,GAAU,SAAS,EAAE,CAAC;AAEvC,+DAA+D;AAC/D,2BAA2B;AAC3B,+DAA+D;AAE/D,SAAS,aAAa,CAAC,OAAe;IACpC,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,OAAO,CAAC,IAAI,OAAO,IAAI,CAAC,EAAE,CAAC;QAC9C,MAAM,IAAI,KAAK,CAAC,4DAA4D,OAAO,GAAG,CAAC,CAAC;IAC1F,CAAC;AACH,CAAC;AAED,SAAS,WAAW,CAAC,KAAa;IAChC,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC,IAAI,KAAK,GAAG,CAAC,IAAI,KAAK,IAAI,CAAC,EAAE,CAAC;QACvD,MAAM,IAAI,KAAK,CAAC,yDAAyD,KAAK,GAAG,CAAC,CAAC;IACrF,CAAC;AACH,CAAC;AAED,SAAS,iBAAiB,CAAC,WAAmB;IAC5C,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,WAAW,CAAC,IAAI,WAAW,GAAG,CAAC,EAAE,CAAC;QACrD,MAAM,IAAI,KAAK,CAAC,gEAAgE,WAAW,GAAG,CAAC,CAAC;IAClG,CAAC;AACH,CAAC;AAED,+DAA+D;AAC/D,sBAAsB;AACtB,+DAA+D;AAE/D;;;GAGG;AACH,SAAgB,YAAY,CAC1B,KAAa,EACb,WAAmB,EACnB,OAAe,EACf,MAAa,WAAW;IAExB,aAAa,CAAC,OAAO,CAAC,CAAC;IACvB,iBAAiB,CAAC,WAAW,CAAC,CAAC;IAC/B,IAAI,WAAW,KAAK,CAAC;QAAE,OAAO,KAAK,CAAC;IACpC,MAAM,CAAC,GAAG,WAAW,GAAG,OAAO,CAAC;IAChC,OAAO,KAAK,GAAG,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC;AAChC,CAAC;AAED;;;;;;;GAOG;AACH,SAAgB,aAAa,CAC3B,KAAa,EACb,WAAmB,EACnB,OAAe,EACf,KAAa,EACb,MAAa,WAAW;IAExB,aAAa,CAAC,OAAO,CAAC,CAAC;IACvB,WAAW,CAAC,KAAK,CAAC,CAAC;IACnB,iBAAiB,CAAC,WAAW,CAAC,CAAC;IAC/B,IAAI,KAAK,KAAK,CAAC,EAAE,CAAC;QAChB,MAAM,IAAI,KAAK,CAAC,4CAA4C,CAAC,CAAC;IAChE,CAAC;IACD,IAAI,WAAW,KAAK,CAAC;QAAE,OAAO,KAAK,CAAC;IACpC,MAAM,KAAK,GAAG,CAAC,WAAW,GAAG,IAAI,CAAC,IAAI,CAAC,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,IAAI,GAAG,KAAK,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC;IAC9E,OAAO,KAAK,GAAG,GAAG,CAAC,QAAQ,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC;AACxC,CAAC;AAED;;;;;GAKG;AACH,SAAgB,oBAAoB,CAClC,KAAU,EACV,KAA0B,EAC1B,WAAmB,EACnB,OAAe,EACf,MAAa,WAAW;IAExB,aAAa,CAAC,OAAO,CAAC,CAAC;IACvB,iBAAiB,CAAC,WAAW,CAAC,CAAC;IAC/B,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QACvB,MAAM,IAAI,KAAK,CAAC,mCAAmC,CAAC,CAAC;IACvD,CAAC;IACD,IAAI,WAAW,KAAK,CAAC,EAAE,CAAC;QACtB,wCAAwC;QACxC,IAAI,IAAI,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC;QACpB,IAAI,SAAS,GAAG,KAAK,CAAC,IAAI,CAAC,CAAC;QAC5B,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,KAAK,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;YACtC,MAAM,IAAI,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC;YACtB,MAAM,CAAC,GAAG,KAAK,CAAC,IAAI,CAAC,CAAC;YACtB,IAAI,CAAC,GAAG,SAAS,EAAE,CAAC;gBAClB,SAAS,GAAG,CAAC,CAAC;gBACd,IAAI,GAAG,IAAI,CAAC;YACd,CAAC;QACH,CAAC;QACD,OAAO,IAAI,CAAC;IACd,CAAC;IACD,MAAM,MAAM,GAAG,KAAK,CAAC,GAAG,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC,CAAC;IAC5C,kEAAkE;IAClE,IAAI,QAAQ,GAAG,CAAC,QAAQ,CAAC;IACzB,KAAK,MAAM,CAAC,IAAI,MAAM,EAAE,CAAC;QACvB,IAAI,CAAC,GAAG,QAAQ;YAAE,QAAQ,GAAG,CAAC,CAAC;IACjC,CAAC;IACD,MAAM,OAAO,GAAG,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,OAAO,GAAG,CAAC,CAAC,GAAG,QAAQ,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,WAAW,CAAC,CAAC,CAAC,CAAC;IAC5F,IAAI,KAAK,GAAG,CAAC,CAAC;IACd,KAAK,MAAM,CAAC,IAAI,OAAO;QAAE,KAAK,IAAI,CAAC,CAAC;IACpC,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC,IAAI,KAAK,IAAI,CAAC,EAAE,CAAC;QAC1C,MAAM,IAAI,KAAK,CAAC,8CAA8C,CAAC,CAAC;IAClE,CAAC;IACD,MAAM,CAAC,GAAG,GAAG,CAAC,OAAO,EAAE,GAAG,KAAK,CAAC;IAChC,IAAI,GAAG,GAAG,CAAC,CAAC;IACZ,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,KAAK,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;QACtC,GAAG,IAAI,OAAO,CAAC,CAAC,CAAC,CAAC;QAClB,IAAI,CAAC,GAAG,GAAG;YAAE,OAAO,KAAK,CAAC,CAAC,CAAC,CAAC;IAC/B,CAAC;IACD,OAAO,KAAK,CAAC,KAAK,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;AACjC,CAAC;AAED;;;;GAIG;AACH,SAAgB,kBAAkB,CAAC,GAAY,EAAE,CAAS,EAAE,MAAa,WAAW;IAClF,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC;QAC5C,MAAM,IAAI,KAAK,CAAC,mDAAmD,CAAC,GAAG,CAAC,CAAC;IAC3E,CAAC;IACD,OAAO,GAAG,CAAC,OAAO,EAAE,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC;AACxC,CAAC;AAED;;;GAGG;AACH,SAAgB,yBAAyB,CAAC,CAAS;IACjD,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC;QAC5C,MAAM,IAAI,KAAK,CAAC,0DAA0D,CAAC,GAAG,CAAC,CAAC;IAClF,CAAC;IACD,OAAO,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;AACzC,CAAC;AAED,+DAA+D;AAC/D,oBAAoB;AACpB,+DAA+D;AAE/D;;;;;GAKG;AACH,SAAgB,OAAO,CACrB,MAAW,EACX,SAA4B,EAC5B,OAAe,EACf,MAAa,WAAW;IAExB,aAAa,CAAC,OAAO,CAAC,CAAC;IACvB,IAAI,KAAK,GAAG,CAAC,CAAC;IACd,KAAK,MAAM,CAAC,IAAI,MAAM,EAAE,CAAC;QACvB,IAAI,SAAS,CAAC,CAAC,CAAC;YAAE,KAAK,EAAE,CAAC;IAC5B,CAAC;IACD,MAAM,KAAK,GAAG,YAAY,CAAC,KAAK,EAAE,CAAC,EAAE,OAAO,EAAE,GAAG,CAAC,CAAC;IACnD,OAAO,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC;AACxC,CAAC;AAED;;;;GAIG;AACH,SAAgB,MAAM,CACpB,MAAgB,EAChB,KAAuB,EACvB,OAAe,EACf,MAAa,WAAW;IAExB,aAAa,CAAC,OAAO,CAAC,CAAC;IACvB,MAAM,CAAC,GAAG,EAAE,IAAI,CAAC,GAAG,KAAK,CAAC;IAC1B,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,GAAG,CAAC,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAI,IAAI,IAAI,GAAG,EAAE,CAAC;QACnE,MAAM,IAAI,KAAK,CAAC,2BAA2B,GAAG,KAAK,IAAI,GAAG,CAAC,CAAC;IAC9D,CAAC;IACD,IAAI,MAAM,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QACxB,MAAM,IAAI,KAAK,CAAC,sBAAsB,CAAC,CAAC;IAC1C,CAAC;IACD,MAAM,CAAC,GAAG,MAAM,CAAC,MAAM,CAAC;IACxB,IAAI,GAAG,GAAG,CAAC,CAAC;IACZ,KAAK,MAAM,CAAC,IAAI,MAAM,EAAE,CAAC;QACvB,MAAM,OAAO,GAAG,CAAC,GAAG,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC;QACpD,GAAG,IAAI,OAAO,CAAC;IACjB,CAAC;IACD,MAAM,IAAI,GAAG,GAAG,GAAG,CAAC,CAAC;IACrB,MAAM,WAAW,GAAG,CAAC,IAAI,GAAG,GAAG,CAAC,GAAG,CAAC,CAAC;IACrC,OAAO,YAAY,CAAC,IAAI,EAAE,WAAW,EAAE,OAAO,EAAE,GAAG,CAAC,CAAC;AACvD,CAAC;AAED;;;;;;;GAOG;AACH,SAAgB,WAAW,CACzB,MAAW,EACX,UAAe,EACf,OAAe,EACf,MAAa,WAAW;IAExB,aAAa,CAAC,OAAO,CAAC,CAAC;IACvB,MAAM,MAAM,GAAG,IAAI,GAAG,EAAa,CAAC;IACpC,KAAK,MAAM,CAAC,IAAI,UAAU;QAAE,MAAM,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;IAC7C,KAAK,MAAM,CAAC,IAAI,MAAM,EAAE,CAAC;QACvB,MAAM,GAAG,GAAG,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;QAC1B,IAAI,GAAG,KAAK,SAAS;YAAE,MAAM,CAAC,GAAG,CAAC,CAAC,EAAE,GAAG,GAAG,CAAC,CAAC,CAAC;IAChD,CAAC;IACD,MAAM,GAAG,GAAG,IAAI,GAAG,EAAa,CAAC;IACjC,KAAK,MAAM,CAAC,GAAG,EAAE,GAAG,CAAC,IAAI,MAAM,EAAE,CAAC;QAChC,MAAM,KAAK,GAAG,YAAY,CAAC,GAAG,EAAE,CAAC,EAAE,OAAO,EAAE,GAAG,CAAC,CAAC;QACjD,GAAG,CAAC,GAAG,CAAC,GAAG,EAAE,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;IAC/C,CAAC;IACD,OAAO,GAAG,CAAC;AACb,CAAC;AAWD;;;;;GAKG;AACH,SAAgB,gBAAgB,CAAC,UAA2B;IAC1D,IAAI,OAAO,GAAG,CAAC,CAAC;IAChB,IAAI,KAAK,GAAG,CAAC,CAAC;IACd,KAAK,MAAM,CAAC,IAAI,UAAU,EAAE,CAAC;QAC3B,aAAa,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC;QACzB,WAAW,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC;QACrB,OAAO,IAAI,CAAC,CAAC,OAAO,CAAC;QACrB,KAAK,IAAI,CAAC,CAAC,KAAK,CAAC;IACnB,CAAC;IACD,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,CAAC;AAC5B,CAAC;AAED;;;;;;;;;;;;GAYG;AACH,SAAgB,mBAAmB,CACjC,UAA2B,EAC3B,UAAkB;IAElB,IAAI,UAAU,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QAC5B,OAAO,EAAE,OAAO,EAAE,CAAC,EAAE,KAAK,EAAE,UAAU,EAAE,CAAC;IAC3C,CAAC;IACD,WAAW,CAAC,UAAU,CAAC,CAAC;IACxB,IAAI,UAAU,IAAI,CAAC,EAAE,CAAC;QACpB,MAAM,IAAI,KAAK,CAAC,8CAA8C,CAAC,CAAC;IAClE,CAAC;IACD,IAAI,MAAM,GAAG,CAAC,CAAC;IACf,IAAI,QAAQ,GAAG,CAAC,CAAC;IACjB,KAAK,MAAM,CAAC,IAAI,UAAU,EAAE,CAAC;QAC3B,aAAa,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC;QACzB,WAAW,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC;QACrB,IAAI,CAAC,CAAC,OAAO,GAAG,MAAM;YAAE,MAAM,GAAG,CAAC,CAAC,OAAO,CAAC;QAC3C,QAAQ,IAAI,CAAC,CAAC,KAAK,CAAC;IACtB,CAAC;IACD,MAAM,CAAC,GAAG,UAAU,CAAC,MAAM,CAAC;IAC5B,MAAM,GAAG,GAAG,MAAM,CAAC;IACnB,MAAM,eAAe,GACnB,IAAI,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,GAAG,UAAU,CAAC,CAAC,GAAG,GAAG,GAAG,CAAC,GAAG,GAAG,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC;IACpF,OAAO,EAAE,OAAO,EAAE,eAAe,EAAE,KAAK,EAAE,QAAQ,GAAG,UAAU,EAAE,CAAC;AACpE,CAAC;AAED;;;;;GAKG;AACH,SAAgB,mBAAmB,CAAC,UAA2B;IAC7D,IAAI,MAAM,GAAG,CAAC,CAAC;IACf,IAAI,QAAQ,GAAG,CAAC,CAAC;IACjB,KAAK,MAAM,CAAC,IAAI,UAAU,EAAE,CAAC;QAC3B,aAAa,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC;QACzB,WAAW,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC;QACrB,IAAI,CAAC,CAAC,OAAO,GAAG,MAAM;YAAE,MAAM,GAAG,CAAC,CAAC,OAAO,CAAC;QAC3C,IAAI,CAAC,CAAC,KAAK,GAAG,QAAQ;YAAE,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC;IAC7C,CAAC;IACD,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,QAAQ,EAAE,CAAC;AAC9C,CAAC;AAED,+DAA+D;AAC/D,0BAA0B;AAC1B,+DAA+D;AAE/D;;;;;GAKG;AACH,SAAgB,mBAAmB,CACjC,EAA8B,EAC9B,SAAsC;IAEtC,IAAI,GAAG,GAAG,CAAC,CAAC;IACZ,KAAK,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,IAAI,SAAS,EAAE,CAAC;QAC/B,MAAM,IAAI,GAAG,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC;QACrC,IAAI,IAAI,GAAG,GAAG;YAAE,GAAG,GAAG,IAAI,CAAC;IAC7B,CAAC;IACD,OAAO,GAAG,CAAC;AACb,CAAC;AAED;;;;;;;;;;;;;GAaG;AACH,SAAgB,iBAAiB,CAC/B,EAA8B,EAC9B,IAAc,EACd,IAAY;IAEZ,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAI,IAAI,IAAI,CAAC,EAAE,CAAC;QACxC,MAAM,IAAI,KAAK,CAAC,6CAA6C,IAAI,GAAG,CAAC,CAAC;IACxE,CAAC;IACD,IAAI,IAAI,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,CAAC,CAAC;IAChC,8DAA8D;IAC9D,IAAI,EAAE,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC;IACjB,IAAI,EAAE,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC;IACjB,KAAK,MAAM,CAAC,IAAI,IAAI,EAAE,CAAC;QACrB,IAAI,CAAC,GAAG,EAAE;YAAE,EAAE,GAAG,CAAC,CAAC;QACnB,IAAI,CAAC,GAAG,EAAE;YAAE,EAAE,GAAG,CAAC,CAAC;IACrB,CAAC;IACD,MAAM,IAAI,GAAG,EAAE,CAAC,IAAI,CAAC,CAAC;IACtB,IAAI,GAAG,GAAG,CAAC,CAAC;IACZ,mEAAmE;IACnE,wEAAwE;IACxE,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,IAAI,IAAI,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;QACtC,8DAA8D;QAC9D,8DAA8D;QAC9D,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,EAAE,CAAC;QAC3B,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,EAAE,CAAC;QAC3B,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC;YAC3B,KAAK,CAAC,CAAC,CAAC,GAAG,EAAE,CAAC;YACd,KAAK,CAAC,CAAC,CAAC,GAAG,EAAE,CAAC;QAChB,CAAC;QACD,MAAM,GAAG,GAAG,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,KAAK,CAAC,GAAG,IAAI,CAAC,CAAC;QACvC,MAAM,GAAG,GAAG,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,KAAK,CAAC,GAAG,IAAI,CAAC,CAAC;QACvC,MAAM,GAAG,GAAG,IAAI,CAAC,GAAG,CAAC,GAAG,EAAE,GAAG,CAAC,CAAC;QAC/B,MAAM,QAAQ,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,IAAI,GAAG,CAAC,CAAC,GAAG,GAAG,CAAC;QAC3C,IAAI,QAAQ,GAAG,GAAG;YAAE,GAAG,GAAG,QAAQ,CAAC;IACrC,CAAC;IACD,OAAO,GAAG,CAAC;AACb,CAAC"}

package/dist/reasoning/mechanism-design/auctions.d.ts

@@ -0,0 +1,49 @@
+import type { AuctionResult } from './types';
+/**
+ * First-price sealed-bid: el ganador paga su propio bid.
+ *
+ * No es strategy-proof — el bidder racional shadea su bid bajo su
+ * valuation. Pero la regla es lo más simple del mundo.
+ */
+export declare function firstPriceSealed(bids: Map<string, number>): AuctionResult;
+/**
+ * Second-price sealed-bid (Vickrey): el ganador paga el segundo bid más
+ * alto. Es DSIC: bidding truthful es dominante.
+ *
+ * Si solo hay un bidder válido, paga 0 (no hay segundo precio). Esa es
+ * la convención estándar; en variantes con reserve, el reserve actúa
+ * como segundo precio si no hay otro bidder por encima.
+ */
+export declare function secondPriceSealed(bids: Map<string, number>): AuctionResult;
+/**
+ * English ascending auction: simulamos un reloj que sube en pasos de
+ * `increment`. Cada bidder sigue activo mientras el precio no supere
+ * su valuation. Cuando solo queda 1 activo, termina y paga el precio
+ * actual.
+ *
+ * Bajo bidders racionales (cada uno dropea exactamente en su valuation),
+ * el resultado es equivalente a second-price (el ganador paga ~ segundo
+ * valor más alto, módulo `increment`).
+ *
+ * Implementación: en vez de simular reloj, calculamos directo:
+ *   winner = bidder con max valuation
+ *   payment = ceil(secondHighest / increment) * increment   ≈ second + un step
+ *
+ * Para los tests usamos increment=1, lo que da payment ≈ second.
+ */
+export declare function englishAuction(bids: Map<string, number>, increment: number): AuctionResult;
+/**
+ * Dutch descending auction: reloj baja desde `initialPrice` con pasos
+ * `decrement`. El primer bidder en aceptar (precio ≤ su valuation)
+ * gana y paga ese precio.
+ *
+ * Estratégicamente, Dutch ≡ first-price sealed: cada bidder elige a qué
+ * precio aceptar, equivalente a elegir su bid. Implementamos via
+ * simulación discreta.
+ *
+ * `bidders.get(id)` = valor máximo que el bidder está dispuesto a pagar
+ * (su bid efectivo en el equivalente sealed). El primero en alcanzar
+ * un precio ≤ a su bid gana.
+ */
+export declare function dutchAuction(initialPrice: number, bidders: Map<string, number>, decrement: number): AuctionResult;
+//# sourceMappingURL=auctions.d.ts.map

package/dist/reasoning/mechanism-design/auctions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"auctions.d.ts","sourceRoot":"","sources":["../../../src/reasoning/mechanism-design/auctions.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAmB7C;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,aAAa,CAIzE;AAED;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,aAAa,CAsB1E;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,SAAS,EAAE,MAAM,GAAG,aAAa,CAkC1F;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,YAAY,CAC1B,YAAY,EAAE,MAAM,EACpB,OAAO,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,EAC5B,SAAS,EAAE,MAAM,GAChB,aAAa,CA6Bf"}

package/dist/reasoning/mechanism-design/auctions.js

@@ -0,0 +1,179 @@
+"use strict";
+// ============================================================
+// Single-item auctions: first/second-price sealed, English, Dutch
+// ============================================================
+//
+// Convención: bids con valor <= 0 se ignoran (no participa). Si no hay
+// bidders válidos, devolvemos { winner: '', payment: 0 }. Empates se
+// rompen lexicográficamente por id (determinista, testeable).
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.firstPriceSealed = firstPriceSealed;
+exports.secondPriceSealed = secondPriceSealed;
+exports.englishAuction = englishAuction;
+exports.dutchAuction = dutchAuction;
+/** Tie-breaking determinista: max bid, ties por id ascendente. */
+function pickWinner(bids) {
+    let winner = '';
+    let bestBid = -Infinity;
+    // Orden lexicográfico de ids para empates reproducibles.
+    const ids = [...bids.keys()].sort();
+    for (const id of ids) {
+        const b = bids.get(id) ?? 0;
+        if (b > bestBid) {
+            bestBid = b;
+            winner = id;
+        }
+    }
+    if (bestBid <= 0 || winner === '')
+        return { winner: '', bid: 0 };
+    return { winner, bid: bestBid };
+}
+/**
+ * First-price sealed-bid: el ganador paga su propio bid.
+ *
+ * No es strategy-proof — el bidder racional shadea su bid bajo su
+ * valuation. Pero la regla es lo más simple del mundo.
+ */
+function firstPriceSealed(bids) {
+    const { winner, bid } = pickWinner(bids);
+    if (winner === '')
+        return { winner: '', payment: 0 };
+    return { winner, payment: bid };
+}
+/**
+ * Second-price sealed-bid (Vickrey): el ganador paga el segundo bid más
+ * alto. Es DSIC: bidding truthful es dominante.
+ *
+ * Si solo hay un bidder válido, paga 0 (no hay segundo precio). Esa es
+ * la convención estándar; en variantes con reserve, el reserve actúa
+ * como segundo precio si no hay otro bidder por encima.
+ */
+function secondPriceSealed(bids) {
+    const ids = [...bids.keys()].sort();
+    if (ids.length === 0)
+        return { winner: '', payment: 0 };
+    // Localizamos el primero y segundo bid más alto.
+    let winner = '';
+    let first = -Infinity;
+    let second = 0;
+    for (const id of ids) {
+        const b = bids.get(id) ?? 0;
+        if (b > first) {
+            second = first === -Infinity ? 0 : first;
+            first = b;
+            winner = id;
+        }
+        else if (b > second) {
+            second = b;
+        }
+    }
+    if (first <= 0 || winner === '')
+        return { winner: '', payment: 0 };
+    // Si no hubo "segundo" real (todos los otros 0 o ausentes), pagan 0.
+    if (second < 0)
+        second = 0;
+    return { winner, payment: second };
+}
+/**
+ * English ascending auction: simulamos un reloj que sube en pasos de
+ * `increment`. Cada bidder sigue activo mientras el precio no supere
+ * su valuation. Cuando solo queda 1 activo, termina y paga el precio
+ * actual.
+ *
+ * Bajo bidders racionales (cada uno dropea exactamente en su valuation),
+ * el resultado es equivalente a second-price (el ganador paga ~ segundo
+ * valor más alto, módulo `increment`).
+ *
+ * Implementación: en vez de simular reloj, calculamos directo:
+ *   winner = bidder con max valuation
+ *   payment = ceil(secondHighest / increment) * increment   ≈ second + un step
+ *
+ * Para los tests usamos increment=1, lo que da payment ≈ second.
+ */
+function englishAuction(bids, increment) {
+    if (increment <= 0)
+        throw new Error('English auction increment must be > 0');
+    const ids = [...bids.keys()].sort();
+    if (ids.length === 0)
+        return { winner: '', payment: 0 };
+    let winner = '';
+    let first = -Infinity;
+    let second = 0;
+    for (const id of ids) {
+        const b = bids.get(id) ?? 0;
+        if (b > first) {
+            second = first === -Infinity ? 0 : first;
+            first = b;
+            winner = id;
+        }
+        else if (b > second) {
+            second = b;
+        }
+    }
+    if (first <= 0 || winner === '')
+        return { winner: '', payment: 0 };
+    if (second < 0)
+        second = 0;
+    // El reloj cruzó el step inmediatamente sobre `second`. Si second cae
+    // exactamente en un múltiplo de increment, el segundo bidder dropea
+    // justo y el ganador paga `second`. Si no, paga el siguiente step.
+    let payment;
+    const steps = Math.floor(second / increment);
+    const onGrid = Math.abs(second - steps * increment) < 1e-9;
+    if (onGrid) {
+        payment = second;
+    }
+    else {
+        payment = (steps + 1) * increment;
+    }
+    if (payment > first)
+        payment = first;
+    return { winner, payment };
+}
+/**
+ * Dutch descending auction: reloj baja desde `initialPrice` con pasos
+ * `decrement`. El primer bidder en aceptar (precio ≤ su valuation)
+ * gana y paga ese precio.
+ *
+ * Estratégicamente, Dutch ≡ first-price sealed: cada bidder elige a qué
+ * precio aceptar, equivalente a elegir su bid. Implementamos via
+ * simulación discreta.
+ *
+ * `bidders.get(id)` = valor máximo que el bidder está dispuesto a pagar
+ * (su bid efectivo en el equivalente sealed). El primero en alcanzar
+ * un precio ≤ a su bid gana.
+ */
+function dutchAuction(initialPrice, bidders, decrement) {
+    if (decrement <= 0)
+        throw new Error('Dutch auction decrement must be > 0');
+    if (initialPrice < 0)
+        throw new Error('Dutch auction initialPrice must be >= 0');
+    const ids = [...bidders.keys()].sort();
+    if (ids.length === 0)
+        return { winner: '', payment: 0 };
+    let price = initialPrice;
+    // Tolerancia para no caer en loops infinitos por floating-point.
+    const maxSteps = Math.ceil(initialPrice / decrement) + 1;
+    for (let step = 0; step <= maxSteps; step++) {
+        // Snapshot del precio actual; bidders elegibles = bid >= price.
+        let candidate = '';
+        let candidateBid = -Infinity;
+        for (const id of ids) {
+            const b = bidders.get(id) ?? 0;
+            if (b >= price - 1e-12 && b > candidateBid) {
+                candidateBid = b;
+                candidate = id;
+            }
+        }
+        if (candidate !== '') {
+            // El primero en aceptar paga el precio actual (clamp a >= 0).
+            const payment = Math.max(0, price);
+            return { winner: candidate, payment };
+        }
+        price -= decrement;
+        if (price < 0)
+            break;
+    }
+    return { winner: '', payment: 0 };
+}
+//# sourceMappingURL=auctions.js.map