@stevenvo780/st-lang 4.7.0 → 4.8.0

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

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

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

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

@@ -0,0 +1,5 @@
+export type { Agent, MechanismOutcome, AuctionResult, SealedBidAuction, BidderDistribution, } from './types';
+export { vcgMechanism, socialWelfare, isStrategyProof } from './vcg';
+export { firstPriceSealed, secondPriceSealed, englishAuction, dutchAuction } from './auctions';
+export { myersonOptimal, virtualValuation, findReserve, expectedRevenue, sampleFromDistribution, uniformDistribution, } from './myerson';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/reasoning/mechanism-design/index.ts"],"names":[],"mappings":"AAoBA,YAAY,EACV,KAAK,EACL,gBAAgB,EAChB,aAAa,EACb,gBAAgB,EAChB,kBAAkB,GACnB,MAAM,SAAS,CAAC;AAEjB,OAAO,EAAE,YAAY,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,OAAO,CAAC;AAErE,OAAO,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,cAAc,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAE/F,OAAO,EACL,cAAc,EACd,gBAAgB,EAChB,WAAW,EACX,eAAe,EACf,sBAAsB,EACtB,mBAAmB,GACpB,MAAM,WAAW,CAAC"}

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

@@ -0,0 +1,39 @@
+"use strict";
+// ============================================================
+// Mechanism design — barrel público
+// ============================================================
+//
+// Implementación de los mecanismos canónicos de la teoría:
+//
+//   - VCG (Vickrey-Clarke-Groves): allocation que maximiza welfare,
+//     pagos por externalidad. DSIC.
+//   - First-price sealed-bid: ganador paga su bid.
+//   - Second-price sealed-bid (Vickrey): ganador paga el segundo
+//     precio. DSIC. Coincide con VCG para 1 item.
+//   - English ascending: reloj sube, sale el último parado.
+//   - Dutch descending: reloj baja, gana el primero en aceptar.
+//   - Myerson optimal auction: maximiza expected revenue via virtual
+//     valuations + reserve price.
+//
+// Helpers:
+//   - socialWelfare, isStrategyProof (empírico)
+//   - virtualValuation, expectedRevenue (Monte Carlo)
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uniformDistribution = exports.sampleFromDistribution = exports.expectedRevenue = exports.findReserve = exports.virtualValuation = exports.myersonOptimal = exports.dutchAuction = exports.englishAuction = exports.secondPriceSealed = exports.firstPriceSealed = exports.isStrategyProof = exports.socialWelfare = exports.vcgMechanism = void 0;
+var vcg_1 = require("./vcg");
+Object.defineProperty(exports, "vcgMechanism", { enumerable: true, get: function () { return vcg_1.vcgMechanism; } });
+Object.defineProperty(exports, "socialWelfare", { enumerable: true, get: function () { return vcg_1.socialWelfare; } });
+Object.defineProperty(exports, "isStrategyProof", { enumerable: true, get: function () { return vcg_1.isStrategyProof; } });
+var auctions_1 = require("./auctions");
+Object.defineProperty(exports, "firstPriceSealed", { enumerable: true, get: function () { return auctions_1.firstPriceSealed; } });
+Object.defineProperty(exports, "secondPriceSealed", { enumerable: true, get: function () { return auctions_1.secondPriceSealed; } });
+Object.defineProperty(exports, "englishAuction", { enumerable: true, get: function () { return auctions_1.englishAuction; } });
+Object.defineProperty(exports, "dutchAuction", { enumerable: true, get: function () { return auctions_1.dutchAuction; } });
+var myerson_1 = require("./myerson");
+Object.defineProperty(exports, "myersonOptimal", { enumerable: true, get: function () { return myerson_1.myersonOptimal; } });
+Object.defineProperty(exports, "virtualValuation", { enumerable: true, get: function () { return myerson_1.virtualValuation; } });
+Object.defineProperty(exports, "findReserve", { enumerable: true, get: function () { return myerson_1.findReserve; } });
+Object.defineProperty(exports, "expectedRevenue", { enumerable: true, get: function () { return myerson_1.expectedRevenue; } });
+Object.defineProperty(exports, "sampleFromDistribution", { enumerable: true, get: function () { return myerson_1.sampleFromDistribution; } });
+Object.defineProperty(exports, "uniformDistribution", { enumerable: true, get: function () { return myerson_1.uniformDistribution; } });
+//# sourceMappingURL=index.js.map

package/dist/reasoning/mechanism-design/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/reasoning/mechanism-design/index.ts"],"names":[],"mappings":";AAAA,+DAA+D;AAC/D,oCAAoC;AACpC,+DAA+D;AAC/D,EAAE;AACF,2DAA2D;AAC3D,EAAE;AACF,oEAAoE;AACpE,oCAAoC;AACpC,mDAAmD;AACnD,iEAAiE;AACjE,kDAAkD;AAClD,4DAA4D;AAC5D,gEAAgE;AAChE,qEAAqE;AACrE,kCAAkC;AAClC,EAAE;AACF,WAAW;AACX,gDAAgD;AAChD,sDAAsD;;;AAUtD,6BAAqE;AAA5D,mGAAA,YAAY,OAAA;AAAE,oGAAA,aAAa,OAAA;AAAE,sGAAA,eAAe,OAAA;AAErD,uCAA+F;AAAtF,4GAAA,gBAAgB,OAAA;AAAE,6GAAA,iBAAiB,OAAA;AAAE,0GAAA,cAAc,OAAA;AAAE,wGAAA,YAAY,OAAA;AAE1E,qCAOmB;AANjB,yGAAA,cAAc,OAAA;AACd,2GAAA,gBAAgB,OAAA;AAChB,sGAAA,WAAW,OAAA;AACX,0GAAA,eAAe,OAAA;AACf,iHAAA,sBAAsB,OAAA;AACtB,8GAAA,mBAAmB,OAAA"}

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

@@ -0,0 +1,64 @@
+import type { BidderDistribution, AuctionResult } from './types';
+/**
+ * Virtual valuation φ(v) = v - (1 - F(v)) / f(v).
+ *
+ * Si f(v) ≈ 0 retornamos +Infinity (límite del término penalty).
+ * Si v cae fuera del dominio, devolvemos -Infinity (no participa).
+ */
+export declare function virtualValuation(v: number, dist: BidderDistribution): number;
+/**
+ * Resuelve φ(r) = 0 por bisección en el dominio de la distribución.
+ *
+ * Si φ(lo) >= 0, devuelve lo. Si φ(hi) <= 0, devuelve hi. Si no, busca
+ * con tolerancia 1e-8 en 80 iteraciones.
+ *
+ * Asume regularidad de la distribución (φ monótona creciente). En
+ * uniform[0,1]: φ(v) = 2v - 1, raíz en 1/2. ✔
+ */
+export declare function findReserve(dist: BidderDistribution): number;
+/**
+ * Myerson optimal auction (single-item).
+ *
+ * - Si todos los φ_i(bid_i) son negativos → no se vende. winner='',
+ *   payment=0, reserve = φ_i^(-1)(0) del primer bidder (referencia).
+ *
+ * - Si el ganador es bidder i (max φ), paga el menor v' tal que
+ *   reportar v' lo habría hecho ganar:
+ *
+ *     paymentValue = max( reserve_i, min_v { v : φ_i(v) >= max_{j≠i} φ_j(bid_j) } )
+ *
+ *   En el caso IID con simétria, esto es:
+ *     paymentValue = max( reserve, secondHighestBid )
+ *
+ *   que es exactamente Vickrey con reserve.
+ */
+export declare function myersonOptimal(bids: Map<string, number>, distributions: Map<string, BidderDistribution>): {
+    winner: string;
+    payment: number;
+    reserve: number;
+};
+/**
+ * Muestrea una valuation de una distribución por inverse-CDF
+ * sampling. Usamos bisección sobre F.
+ */
+export declare function sampleFromDistribution(dist: BidderDistribution, u: number): number;
+/**
+ * Expected revenue de un mechanism via Monte Carlo: muestreamos
+ * `samples` perfiles de bids (cada bidder draw de su distribución
+ * independientemente, asumiendo truthful bidding para 2nd-price /
+ * Myerson, o equilibrium bidding aproximado para 1st-price), corremos
+ * el mechanism y promediamos el payment del ganador.
+ *
+ * Nota: para 1st-price con IID uniform[0,1] y n bidders, el bid
+ * de equilibrio es b(v) = (n-1)/n · v. El caller debe pasar un
+ * mechanism que ya implemente ese mapping si quiere comparar contra
+ * 2nd-price truthful.
+ */
+export declare function expectedRevenue(mechanism: (bids: Map<string, number>) => AuctionResult, distributions: Map<string, BidderDistribution>, samples?: number): number;
+/**
+ * Helper: distribución uniform sobre [a, b]. Útil para tests.
+ * (No exportada en index — solo helper interno aquí; los tests
+ * pueden importarlo directamente.)
+ */
+export declare function uniformDistribution(a: number, b: number): BidderDistribution;
+//# sourceMappingURL=myerson.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"myerson.d.ts","sourceRoot":"","sources":["../../../src/reasoning/mechanism-design/myerson.ts"],"names":[],"mappings":"AAwBA,OAAO,KAAK,EAAE,kBAAkB,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAEjE;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,EAAE,MAAM,EAAE,IAAI,EAAE,kBAAkB,GAAG,MAAM,CAW5E;AAED;;;;;;;;GAQG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,kBAAkB,GAAG,MAAM,CAiB5D;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,cAAc,CAC5B,IAAI,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,EACzB,aAAa,EAAE,GAAG,CAAC,MAAM,EAAE,kBAAkB,CAAC,GAC7C;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAoDtD;AAyBD;;;GAGG;AACH,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,kBAAkB,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAclF;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,eAAe,CAC7B,SAAS,EAAE,CAAC,IAAI,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,KAAK,aAAa,EACvD,aAAa,EAAE,GAAG,CAAC,MAAM,EAAE,kBAAkB,CAAC,EAC9C,OAAO,GAAE,MAAa,GACrB,MAAM,CAeR;AAED;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,kBAAkB,CAe5E"}

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

@@ -0,0 +1,253 @@
+"use strict";
+// ============================================================
+// Myerson optimal auction + revenue equivalence
+// ============================================================
+//
+// Myerson (1981): para vender 1 item a `n` bidders independientes con
+// valuations privadas de distribuciones regulares F_i, el mechanism
+// óptimo en expected revenue es:
+//
+//   1. Calcular virtual valuation φ_i(v) = v - (1 - F_i(v)) / f_i(v).
+//   2. Asignar al bidder con MAYOR φ_i (si > 0, si no, no asignar →
+//      reserve price implícito r_i tal que φ_i(r_i) = 0).
+//   3. Cobrar al ganador el menor bid que lo habría hecho ganar
+//      (Vickrey-style payment sobre virtual valuations).
+//
+// Para distribuciones simétricas (todos los bidders i.i.d. con misma
+// F), φ es la misma función para todos; el mechanism colapsa a una
+// second-price auction con reserve price r = φ^(-1)(0).
+//
+// Revenue equivalence theorem: en cualquier mechanism que (a) asigne
+// al bidder con mayor valuation y (b) dé utilidad 0 al bidder con
+// valuation 0 ("regularity boundary"), el expected revenue es el
+// mismo. → 1st-price y 2nd-price tienen igual revenue esperado bajo
+// IID.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.virtualValuation = virtualValuation;
+exports.findReserve = findReserve;
+exports.myersonOptimal = myersonOptimal;
+exports.sampleFromDistribution = sampleFromDistribution;
+exports.expectedRevenue = expectedRevenue;
+exports.uniformDistribution = uniformDistribution;
+/**
+ * Virtual valuation φ(v) = v - (1 - F(v)) / f(v).
+ *
+ * Si f(v) ≈ 0 retornamos +Infinity (límite del término penalty).
+ * Si v cae fuera del dominio, devolvemos -Infinity (no participa).
+ */
+function virtualValuation(v, dist) {
+    const [lo, hi] = dist.domain;
+    if (v < lo || v > hi)
+        return -Infinity;
+    const f = dist.pdf(v);
+    if (!Number.isFinite(f) || Math.abs(f) < 1e-15) {
+        // En el borde superior, F(v) = 1 → (1-F)/f = 0/0; tomamos v como límite.
+        if (Math.abs(1 - dist.cdf(v)) < 1e-12)
+            return v;
+        return v;
+    }
+    const F = dist.cdf(v);
+    return v - (1 - F) / f;
+}
+/**
+ * Resuelve φ(r) = 0 por bisección en el dominio de la distribución.
+ *
+ * Si φ(lo) >= 0, devuelve lo. Si φ(hi) <= 0, devuelve hi. Si no, busca
+ * con tolerancia 1e-8 en 80 iteraciones.
+ *
+ * Asume regularidad de la distribución (φ monótona creciente). En
+ * uniform[0,1]: φ(v) = 2v - 1, raíz en 1/2. ✔
+ */
+function findReserve(dist) {
+    const [lo, hi] = dist.domain;
+    const phiLo = virtualValuation(lo, dist);
+    const phiHi = virtualValuation(hi, dist);
+    if (phiLo >= 0)
+        return lo;
+    if (phiHi <= 0)
+        return hi;
+    let l = lo;
+    let h = hi;
+    for (let i = 0; i < 80; i++) {
+        const m = (l + h) / 2;
+        const phi = virtualValuation(m, dist);
+        if (phi > 0)
+            h = m;
+        else
+            l = m;
+        if (h - l < 1e-9)
+            break;
+    }
+    return (l + h) / 2;
+}
+/**
+ * Myerson optimal auction (single-item).
+ *
+ * - Si todos los φ_i(bid_i) son negativos → no se vende. winner='',
+ *   payment=0, reserve = φ_i^(-1)(0) del primer bidder (referencia).
+ *
+ * - Si el ganador es bidder i (max φ), paga el menor v' tal que
+ *   reportar v' lo habría hecho ganar:
+ *
+ *     paymentValue = max( reserve_i, min_v { v : φ_i(v) >= max_{j≠i} φ_j(bid_j) } )
+ *
+ *   En el caso IID con simétria, esto es:
+ *     paymentValue = max( reserve, secondHighestBid )
+ *
+ *   que es exactamente Vickrey con reserve.
+ */
+function myersonOptimal(bids, distributions) {
+    const ids = [...bids.keys()].sort();
+    if (ids.length === 0) {
+        return { winner: '', payment: 0, reserve: 0 };
+    }
+    // Buscamos el bidder con mayor virtual valuation positivo.
+    let winner = '';
+    let bestPhi = 0; // estricto > 0 — el reserve viene de φ(r) = 0
+    let secondPhi = 0;
+    for (const id of ids) {
+        const b = bids.get(id) ?? 0;
+        const dist = distributions.get(id);
+        if (!dist)
+            continue;
+        const phi = virtualValuation(b, dist);
+        if (phi > bestPhi) {
+            secondPhi = bestPhi;
+            bestPhi = phi;
+            winner = id;
+        }
+        else if (phi > secondPhi) {
+            secondPhi = phi;
+        }
+    }
+    // Reserve de referencia: del primer bidder (todos los i.i.d. comparten).
+    const firstDist = distributions.get(ids[0]);
+    if (!firstDist) {
+        return { winner: '', payment: 0, reserve: 0 };
+    }
+    const referenceReserve = findReserve(firstDist);
+    if (winner === '') {
+        return { winner: '', payment: 0, reserve: referenceReserve };
+    }
+    const winnerDist = distributions.get(winner);
+    if (!winnerDist) {
+        return { winner: '', payment: 0, reserve: referenceReserve };
+    }
+    const winnerReserve = findReserve(winnerDist);
+    // Pago: el menor valor v* tal que φ_winner(v*) >= max(secondPhi, 0).
+    // En IID: φ es monótona, así que invertimos por bisección.
+    const targetPhi = Math.max(secondPhi, 0);
+    let payment = invertVirtual(winnerDist, targetPhi);
+    if (payment < winnerReserve)
+        payment = winnerReserve;
+    // Sanity: el pago no puede exceder el bid del ganador.
+    const winnerBid = bids.get(winner) ?? 0;
+    if (payment > winnerBid)
+        payment = winnerBid;
+    return { winner, payment, reserve: winnerReserve };
+}
+/**
+ * Inverte φ: encuentra v* tal que φ(v*) = target. Asume regularidad.
+ * Si target <= φ(lo), devuelve lo. Si target >= φ(hi), devuelve hi.
+ */
+function invertVirtual(dist, target) {
+    const [lo, hi] = dist.domain;
+    const phiLo = virtualValuation(lo, dist);
+    const phiHi = virtualValuation(hi, dist);
+    if (target <= phiLo)
+        return lo;
+    if (target >= phiHi)
+        return hi;
+    let l = lo;
+    let h = hi;
+    for (let i = 0; i < 80; i++) {
+        const m = (l + h) / 2;
+        const phi = virtualValuation(m, dist);
+        if (phi >= target)
+            h = m;
+        else
+            l = m;
+        if (h - l < 1e-9)
+            break;
+    }
+    return (l + h) / 2;
+}
+/**
+ * Muestrea una valuation de una distribución por inverse-CDF
+ * sampling. Usamos bisección sobre F.
+ */
+function sampleFromDistribution(dist, u) {
+    // u ∈ [0,1]. Encontrar v con F(v) = u.
+    const [lo, hi] = dist.domain;
+    if (u <= 0)
+        return lo;
+    if (u >= 1)
+        return hi;
+    let l = lo;
+    let h = hi;
+    for (let i = 0; i < 80; i++) {
+        const m = (l + h) / 2;
+        if (dist.cdf(m) > u)
+            h = m;
+        else
+            l = m;
+        if (h - l < 1e-9)
+            break;
+    }
+    return (l + h) / 2;
+}
+/**
+ * Expected revenue de un mechanism via Monte Carlo: muestreamos
+ * `samples` perfiles de bids (cada bidder draw de su distribución
+ * independientemente, asumiendo truthful bidding para 2nd-price /
+ * Myerson, o equilibrium bidding aproximado para 1st-price), corremos
+ * el mechanism y promediamos el payment del ganador.
+ *
+ * Nota: para 1st-price con IID uniform[0,1] y n bidders, el bid
+ * de equilibrio es b(v) = (n-1)/n · v. El caller debe pasar un
+ * mechanism que ya implemente ese mapping si quiere comparar contra
+ * 2nd-price truthful.
+ */
+function expectedRevenue(mechanism, distributions, samples = 5000) {
+    const ids = [...distributions.keys()].sort();
+    let totalRevenue = 0;
+    for (let s = 0; s < samples; s++) {
+        const bids = new Map();
+        for (const id of ids) {
+            const dist = distributions.get(id);
+            if (!dist)
+                continue;
+            const u = Math.random();
+            bids.set(id, sampleFromDistribution(dist, u));
+        }
+        const r = mechanism(bids);
+        totalRevenue += r.payment;
+    }
+    return totalRevenue / samples;
+}
+/**
+ * Helper: distribución uniform sobre [a, b]. Útil para tests.
+ * (No exportada en index — solo helper interno aquí; los tests
+ * pueden importarlo directamente.)
+ */
+function uniformDistribution(a, b) {
+    if (b <= a)
+        throw new Error('uniformDistribution: b must be > a');
+    const span = b - a;
+    return {
+        domain: [a, b],
+        cdf: (v) => {
+            if (v <= a)
+                return 0;
+            if (v >= b)
+                return 1;
+            return (v - a) / span;
+        },
+        pdf: (v) => {
+            if (v < a || v > b)
+                return 0;
+            return 1 / span;
+        },
+    };
+}
+//# sourceMappingURL=myerson.js.map

package/dist/reasoning/mechanism-design/myerson.js.map

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

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

@@ -0,0 +1,44 @@
+/**
+ * Un agente con valuation sobre outcomes. Cada outcome se identifica
+ * con un string (típicamente itemId, pero puede codificar bundles
+ * para combinatorial auctions, e.g. "A+B").
+ */
+export interface Agent {
+    id: string;
+    /** valuation.get(outcome) = utilidad si recibe ese outcome. Default 0 si missing. */
+    valuation: Map<string, number>;
+}
+/**
+ * Resultado de un mechanism: quién se queda con qué y cuánto paga.
+ */
+export interface MechanismOutcome {
+    /** allocation.get(agentId) = item que recibe (o undefined si no recibe). */
+    allocation: Map<string, string>;
+    /** payments.get(agentId) = pago del agente al mechanism (>= 0 típicamente). */
+    payments: Map<string, number>;
+}
+/**
+ * Resultado de una single-item auction.
+ */
+export interface AuctionResult {
+    /** Id del ganador (o '' si nadie supera el reserve / no hay bids). */
+    winner: string;
+    /** Pago del ganador. 0 si no hubo ganador. */
+    payment: number;
+}
+/**
+ * Auction con bids sealed (cada bidder reporta un valor secreto).
+ */
+export interface SealedBidAuction {
+    bids: Map<string, number>;
+}
+/**
+ * Distribución (i.i.d. por bidder) sobre la valuation. Necesitamos CDF
+ * y PDF en cerrado para Myerson; el dominio acota el soporte.
+ */
+export interface BidderDistribution {
+    cdf: (v: number) => number;
+    pdf: (v: number) => number;
+    domain: [number, number];
+}
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/reasoning/mechanism-design/types.ts"],"names":[],"mappings":"AAoBA;;;;GAIG;AACH,MAAM,WAAW,KAAK;IACpB,EAAE,EAAE,MAAM,CAAC;IACX,qFAAqF;IACrF,SAAS,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAChC;AAED;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B,4EAA4E;IAC5E,UAAU,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAChC,+EAA+E;IAC/E,QAAQ,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAC/B;AAED;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B,sEAAsE;IACtE,MAAM,EAAE,MAAM,CAAC;IACf,8CAA8C;IAC9C,OAAO,EAAE,MAAM,CAAC;CACjB;AAED;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B,IAAI,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAC3B;AAED;;;GAGG;AACH,MAAM,WAAW,kBAAkB;IACjC,GAAG,EAAE,CAAC,CAAC,EAAE,MAAM,KAAK,MAAM,CAAC;IAC3B,GAAG,EAAE,CAAC,CAAC,EAAE,MAAM,KAAK,MAAM,CAAC;IAC3B,MAAM,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAC1B"}

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

@@ -0,0 +1,22 @@
+"use strict";
+// ============================================================
+// Mechanism design — tipos compartidos
+// ============================================================
+//
+// Modelamos mechanism design discreto sobre un conjunto finito de
+// outcomes (típicamente: asignar ítems a agentes). Cada agente reporta
+// una valuation `Map<outcomeId, number>`. El mechanism elige una
+// allocation y cobra pagos.
+//
+// El bundle de un agente en una allocation es el conjunto de outcomes
+// que se le asignan. Modelamos allocation como `Map<agentId, itemId>`
+// para el caso single-unit (cada item a un solo agente). Para
+// combinatorial auctions se generaliza con bundles, pero el `MechanismOutcome`
+// público mantiene el tipo Map<string,string> según contrato.
+//
+// Los pagos son no-negativos cuando el mechanism es individually
+// rational; aceptamos negativos en VCG con bundles porque las pivots
+// pueden compensar (típicamente VCG cobra >= 0 si la valuation es
+// monotónica, lo que asumimos por construcción de ejemplos).
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=types.js.map

package/dist/reasoning/mechanism-design/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../src/reasoning/mechanism-design/types.ts"],"names":[],"mappings":";AAAA,+DAA+D;AAC/D,uCAAuC;AACvC,+DAA+D;AAC/D,EAAE;AACF,kEAAkE;AAClE,uEAAuE;AACvE,iEAAiE;AACjE,4BAA4B;AAC5B,EAAE;AACF,sEAAsE;AACtE,sEAAsE;AACtE,8DAA8D;AAC9D,+EAA+E;AAC/E,8DAA8D;AAC9D,EAAE;AACF,iEAAiE;AACjE,qEAAqE;AACrE,kEAAkE;AAClE,6DAA6D"}