@stevenvo780/st-lang 4.5.0 → 4.5.2

package/dist/game-theory/common-games.js

@@ -0,0 +1,112 @@
+"use strict";
+// ============================================================
+// Common games — fixtures clásicos para tests y docs.
+// ============================================================
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.prisonersDilemma = prisonersDilemma;
+exports.rockPaperScissors = rockPaperScissors;
+exports.battleOfSexes = battleOfSexes;
+exports.matchingPennies = matchingPennies;
+exports.stagHunt = stagHunt;
+const types_1 = require("./types");
+/**
+ * Prisoner's dilemma. Estrategias: 0=cooperate, 1=defect.
+ * Pagos típicos (T > R > P > S):
+ *   T=5, R=3, P=1, S=0
+ *
+ *           C       D
+ *      C  (3,3)  (0,5)
+ *      D  (5,0)  (1,1)
+ *
+ * Único Nash: (D, D) con payoff (1, 1).
+ */
+function prisonersDilemma() {
+    const p1 = [
+        [3, 0],
+        [5, 1],
+    ];
+    const p2 = [
+        [3, 5],
+        [0, 1],
+    ];
+    return (0, types_1.createTwoPlayerGame)(p1, p2);
+}
+/**
+ * Rock-Paper-Scissors (zero-sum). Estrategias: 0=R, 1=P, 2=S.
+ * Único Nash: (1/3, 1/3, 1/3) por jugador, payoff (0, 0).
+ */
+function rockPaperScissors() {
+    const p1 = [
+        [0, -1, 1],
+        [1, 0, -1],
+        [-1, 1, 0],
+    ];
+    const p2 = [
+        [0, 1, -1],
+        [-1, 0, 1],
+        [1, -1, 0],
+    ];
+    return (0, types_1.createTwoPlayerGame)(p1, p2);
+}
+/**
+ * Battle of the sexes. Dos jugadores prefieren coordinar pero
+ * en cosas distintas. Estrategias: 0=Opera, 1=Football.
+ *
+ *           O       F
+ *      O  (2,1)  (0,0)
+ *      F  (0,0)  (1,2)
+ *
+ * Tres Nash: (O,O), (F,F), mixto.
+ */
+function battleOfSexes() {
+    const p1 = [
+        [2, 0],
+        [0, 1],
+    ];
+    const p2 = [
+        [1, 0],
+        [0, 2],
+    ];
+    return (0, types_1.createTwoPlayerGame)(p1, p2);
+}
+/**
+ * Matching pennies (zero-sum). Estrategias: 0=H, 1=T.
+ *
+ *           H        T
+ *      H  ( 1,-1) (-1, 1)
+ *      T  (-1, 1) ( 1,-1)
+ *
+ * Único Nash: (1/2, 1/2).
+ */
+function matchingPennies() {
+    const p1 = [
+        [1, -1],
+        [-1, 1],
+    ];
+    const p2 = [
+        [-1, 1],
+        [1, -1],
+    ];
+    return (0, types_1.createTwoPlayerGame)(p1, p2);
+}
+/**
+ * Coordination "stag hunt". Estrategias: 0=Stag, 1=Hare.
+ *
+ *           S       H
+ *      S  (4,4)  (0,3)
+ *      H  (3,0)  (2,2)
+ *
+ * Nash puros: (S,S) y (H,H); además uno mixto.
+ */
+function stagHunt() {
+    const p1 = [
+        [4, 0],
+        [3, 2],
+    ];
+    const p2 = [
+        [4, 3],
+        [0, 2],
+    ];
+    return (0, types_1.createTwoPlayerGame)(p1, p2);
+}
+//# sourceMappingURL=common-games.js.map

package/dist/game-theory/common-games.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"common-games.js","sourceRoot":"","sources":["../../src/game-theory/common-games.ts"],"names":[],"mappings":";AAAA,+DAA+D;AAC/D,sDAAsD;AACtD,+DAA+D;;AAgB/D,4CAUC;AAMD,8CAYC;AAYD,sCAUC;AAWD,0CAUC;AAWD,4BAUC;AAzGD,mCAA8C;AAE9C;;;;;;;;;;GAUG;AACH,SAAgB,gBAAgB;IAC9B,MAAM,EAAE,GAAG;QACT,CAAC,CAAC,EAAE,CAAC,CAAC;QACN,CAAC,CAAC,EAAE,CAAC,CAAC;KACP,CAAC;IACF,MAAM,EAAE,GAAG;QACT,CAAC,CAAC,EAAE,CAAC,CAAC;QACN,CAAC,CAAC,EAAE,CAAC,CAAC;KACP,CAAC;IACF,OAAO,IAAA,2BAAmB,EAAC,EAAE,EAAE,EAAE,CAAC,CAAC;AACrC,CAAC;AAED;;;GAGG;AACH,SAAgB,iBAAiB;IAC/B,MAAM,EAAE,GAAG;QACT,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC;QACV,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;QACV,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC;KACX,CAAC;IACF,MAAM,EAAE,GAAG;QACT,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;QACV,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC;QACV,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC;KACX,CAAC;IACF,OAAO,IAAA,2BAAmB,EAAC,EAAE,EAAE,EAAE,CAAC,CAAC;AACrC,CAAC;AAED;;;;;;;;;GASG;AACH,SAAgB,aAAa;IAC3B,MAAM,EAAE,GAAG;QACT,CAAC,CAAC,EAAE,CAAC,CAAC;QACN,CAAC,CAAC,EAAE,CAAC,CAAC;KACP,CAAC;IACF,MAAM,EAAE,GAAG;QACT,CAAC,CAAC,EAAE,CAAC,CAAC;QACN,CAAC,CAAC,EAAE,CAAC,CAAC;KACP,CAAC;IACF,OAAO,IAAA,2BAAmB,EAAC,EAAE,EAAE,EAAE,CAAC,CAAC;AACrC,CAAC;AAED;;;;;;;;GAQG;AACH,SAAgB,eAAe;IAC7B,MAAM,EAAE,GAAG;QACT,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;QACP,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC;KACR,CAAC;IACF,MAAM,EAAE,GAAG;QACT,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC;QACP,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;KACR,CAAC;IACF,OAAO,IAAA,2BAAmB,EAAC,EAAE,EAAE,EAAE,CAAC,CAAC;AACrC,CAAC;AAED;;;;;;;;GAQG;AACH,SAAgB,QAAQ;IACtB,MAAM,EAAE,GAAG;QACT,CAAC,CAAC,EAAE,CAAC,CAAC;QACN,CAAC,CAAC,EAAE,CAAC,CAAC;KACP,CAAC;IACF,MAAM,EAAE,GAAG;QACT,CAAC,CAAC,EAAE,CAAC,CAAC;QACN,CAAC,CAAC,EAAE,CAAC,CAAC;KACP,CAAC;IACF,OAAO,IAAA,2BAAmB,EAAC,EAAE,EAAE,EAAE,CAAC,CAAC;AACrC,CAAC"}

package/dist/game-theory/dominance.d.ts

@@ -0,0 +1,26 @@
+import type { MixedStrategy, NormalFormGame } from './types';
+/**
+ * Devuelve true si la estrategia pura `strategy` del jugador
+ * `player` está dominada por otra pura. Si `strict` es true exige
+ * dominancia estricta, si no permite weak.
+ */
+export declare function isDominated(game: NormalFormGame, player: number, strategy: number, strict?: boolean): boolean;
+/**
+ * Aplica eliminación iterada hasta punto fijo. Devuelve un juego
+ * cuyas estrategias son un subconjunto de las originales.
+ *
+ * Importante: el resultado siempre tiene al menos 1 estrategia por
+ * jugador (la última no se elimina aunque "técnicamente" lo esté,
+ * porque eliminarla deja el juego vacío y sin sentido).
+ */
+export declare function eliminateDominated(game: NormalFormGame, strict?: boolean): NormalFormGame;
+/**
+ * Mejores respuestas puras del jugador `player` dado que los demás
+ * juegan según `opponentStrategies` (debe incluir TODOS los jugadores,
+ * incluyendo el propio — la entrada de `player` se ignora).
+ *
+ * Retorna lista de índices de estrategias puras con utilidad máxima
+ * (puede haber empates).
+ */
+export declare function bestResponse(game: NormalFormGame, player: number, opponentStrategies: MixedStrategy[]): number[];
+//# sourceMappingURL=dominance.d.ts.map

package/dist/game-theory/dominance.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dominance.d.ts","sourceRoot":"","sources":["../../src/game-theory/dominance.ts"],"names":[],"mappings":"AAWA,OAAO,KAAK,EAAE,aAAa,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAG7D;;;;GAIG;AACH,wBAAgB,WAAW,CACzB,IAAI,EAAE,cAAc,EACpB,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,MAAM,EAChB,MAAM,UAAO,GACZ,OAAO,CA6CT;AAED;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,cAAc,EAAE,MAAM,UAAO,GAAG,cAAc,CAuBtF;AA2BD;;;;;;;GAOG;AACH,wBAAgB,YAAY,CAC1B,IAAI,EAAE,cAAc,EACpB,MAAM,EAAE,MAAM,EACd,kBAAkB,EAAE,aAAa,EAAE,GAClC,MAAM,EAAE,CAsCV"}

package/dist/game-theory/dominance.js

@@ -0,0 +1,203 @@
+"use strict";
+// ============================================================
+// Iterated elimination of (strictly|weakly) dominated strategies
+// ============================================================
+//
+// Una estrategia pura `s` del jugador `i` está estrictamente
+// dominada si existe otra estrategia pura `s'` tal que para todo
+// perfil de los demás jugadores, u_i(s', t) > u_i(s, t).
+//
+// La versión "weak" usa ≥ con desigualdad estricta en al menos
+// un perfil. Aquí soportamos `strict` (estricta) y la otra.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isDominated = isDominated;
+exports.eliminateDominated = eliminateDominated;
+exports.bestResponse = bestResponse;
+const types_1 = require("./types");
+/**
+ * Devuelve true si la estrategia pura `strategy` del jugador
+ * `player` está dominada por otra pura. Si `strict` es true exige
+ * dominancia estricta, si no permite weak.
+ */
+function isDominated(game, player, strategy, strict = true) {
+    const sizes = game.strategies;
+    const mySize = sizes[player];
+    if (mySize === undefined)
+        throw new Error(`player ${player} out of range`);
+    const row = game.payoffs[player];
+    if (!row)
+        throw new Error(`payoffs missing for player ${player}`);
+    // Conjunto de "perfiles del oponente" — un índice por combinación de
+    // los demás jugadores. Iteramos los perfiles totales pero solo
+    // miramos los que tienen `strategy` en `player`.
+    const total = (0, types_1.totalProfiles)(sizes);
+    // Para cada alternativa s' != strategy, ver si domina a strategy.
+    for (let alt = 0; alt < mySize; alt++) {
+        if (alt === strategy)
+            continue;
+        let allGE = true;
+        let oneStrictGT = false;
+        for (let idx = 0; idx < total; idx++) {
+            const profile = (0, types_1.indexToProfile)(idx, sizes);
+            if (profile[player] !== strategy)
+                continue;
+            const altProfile = profile.slice();
+            altProfile[player] = alt;
+            const altIdx = (0, types_1.profileToIndex)(altProfile, sizes);
+            const uAlt = row[altIdx];
+            const uCur = row[idx];
+            if (strict) {
+                if (!(uAlt > uCur)) {
+                    allGE = false;
+                    break;
+                }
+            }
+            else {
+                if (uAlt < uCur) {
+                    allGE = false;
+                    break;
+                }
+                if (uAlt > uCur)
+                    oneStrictGT = true;
+            }
+        }
+        if (strict) {
+            if (allGE)
+                return true;
+        }
+        else {
+            if (allGE && oneStrictGT)
+                return true;
+        }
+    }
+    return false;
+}
+/**
+ * Aplica eliminación iterada hasta punto fijo. Devuelve un juego
+ * cuyas estrategias son un subconjunto de las originales.
+ *
+ * Importante: el resultado siempre tiene al menos 1 estrategia por
+ * jugador (la última no se elimina aunque "técnicamente" lo esté,
+ * porque eliminarla deja el juego vacío y sin sentido).
+ */
+function eliminateDominated(game, strict = true) {
+    let cur = game;
+    // Mapeo opcional: índices supervivientes por jugador. No los
+    // exportamos aún; el spec sólo pide el juego reducido.
+    while (true) {
+        const before = (0, types_1.totalProfiles)(cur.strategies);
+        let removedSomething = false;
+        for (let p = 0; p < cur.players; p++) {
+            const size = cur.strategies[p];
+            if (size <= 1)
+                continue;
+            for (let s = 0; s < size; s++) {
+                if (isDominated(cur, p, s, strict)) {
+                    cur = removeStrategy(cur, p, s);
+                    removedSomething = true;
+                    break; // recalcular con el juego más chico
+                }
+            }
+            if (removedSomething)
+                break;
+        }
+        if (!removedSomething)
+            break;
+        if ((0, types_1.totalProfiles)(cur.strategies) === before)
+            break; // safety
+    }
+    return cur;
+}
+/**
+ * Quita una estrategia pura de un jugador y rebuilds payoffs.
+ */
+function removeStrategy(game, player, strategy) {
+    const newSizes = game.strategies.slice();
+    newSizes[player] = newSizes[player] - 1;
+    const newTotal = (0, types_1.totalProfiles)(newSizes);
+    const newPayoffs = [];
+    for (let p = 0; p < game.players; p++) {
+        newPayoffs.push(new Array(newTotal));
+    }
+    for (let newIdx = 0; newIdx < newTotal; newIdx++) {
+        const newProfile = (0, types_1.indexToProfile)(newIdx, newSizes);
+        // Mapear back a perfil viejo: saltar la estrategia eliminada
+        const oldProfile = newProfile.slice();
+        const np = oldProfile[player];
+        oldProfile[player] = np >= strategy ? np + 1 : np;
+        const oldIdx = (0, types_1.profileToIndex)(oldProfile, game.strategies);
+        for (let p = 0; p < game.players; p++) {
+            newPayoffs[p][newIdx] = game.payoffs[p][oldIdx];
+        }
+    }
+    return (0, types_1.createGame)(game.players, newSizes, newPayoffs);
+}
+/**
+ * Mejores respuestas puras del jugador `player` dado que los demás
+ * juegan según `opponentStrategies` (debe incluir TODOS los jugadores,
+ * incluyendo el propio — la entrada de `player` se ignora).
+ *
+ * Retorna lista de índices de estrategias puras con utilidad máxima
+ * (puede haber empates).
+ */
+function bestResponse(game, player, opponentStrategies) {
+    const sizes = game.strategies;
+    const mySize = sizes[player];
+    if (mySize === undefined)
+        throw new Error(`player ${player} out of range`);
+    if (opponentStrategies.length !== game.players) {
+        throw new Error(`expected ${game.players} mixed strategies (one per player including self placeholder)`);
+    }
+    const utilities = new Array(mySize).fill(0);
+    for (let s = 0; s < mySize; s++) {
+        const dists = [];
+        for (let p = 0; p < game.players; p++) {
+            if (p === player) {
+                const d = new Array(mySize).fill(0);
+                d[s] = 1;
+                dists.push(d);
+            }
+            else {
+                dists.push(opponentStrategies[p].distribution);
+            }
+        }
+        utilities[s] = expectedUtility(game, player, dists);
+    }
+    const best = [];
+    let maxU = -Infinity;
+    for (let s = 0; s < mySize; s++) {
+        const u = utilities[s];
+        if (u > maxU + 1e-12) {
+            maxU = u;
+            best.length = 0;
+            best.push(s);
+        }
+        else if (Math.abs(u - maxU) < 1e-9) {
+            best.push(s);
+        }
+    }
+    return best;
+}
+function expectedUtility(game, player, dists) {
+    const sizes = game.strategies;
+    const total = (0, types_1.totalProfiles)(sizes);
+    const row = game.payoffs[player];
+    if (!row)
+        throw new Error(`player ${player} out of range`);
+    let acc = 0;
+    for (let idx = 0; idx < total; idx++) {
+        const profile = (0, types_1.indexToProfile)(idx, sizes);
+        let prob = 1;
+        for (let p = 0; p < profile.length; p++) {
+            const d = dists[p];
+            prob *= d[profile[p]];
+            if (prob === 0)
+                break;
+        }
+        if (prob === 0)
+            continue;
+        acc += prob * row[idx];
+    }
+    return acc;
+}
+//# sourceMappingURL=dominance.js.map

package/dist/game-theory/dominance.js.map

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

package/dist/game-theory/index.d.ts

@@ -0,0 +1,8 @@
+export type { NormalFormGame, MixedStrategy, NashEquilibrium } from './types';
+export { createGame, createTwoPlayerGame, profileToIndex, indexToProfile, totalProfiles, payoffOf, pureDistribution, expectedPayoff, approxEqual, vectorsApproxEqual, } from './types';
+export { findPureNash } from './pure-nash';
+export { enumerateAllNash } from './support-enumeration';
+export { lemkeHowson } from './lemke-howson';
+export { isDominated, eliminateDominated, bestResponse } from './dominance';
+export { prisonersDilemma, rockPaperScissors, battleOfSexes, matchingPennies, stagHunt, } from './common-games';
+//# sourceMappingURL=index.d.ts.map

package/dist/game-theory/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/game-theory/index.ts"],"names":[],"mappings":"AAiBA,YAAY,EAAE,cAAc,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAC9E,OAAO,EACL,UAAU,EACV,mBAAmB,EACnB,cAAc,EACd,cAAc,EACd,aAAa,EACb,QAAQ,EACR,gBAAgB,EAChB,cAAc,EACd,WAAW,EACX,kBAAkB,GACnB,MAAM,SAAS,CAAC;AAEjB,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAC3C,OAAO,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AACzD,OAAO,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAE7C,OAAO,EAAE,WAAW,EAAE,kBAAkB,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAE5E,OAAO,EACL,gBAAgB,EAChB,iBAAiB,EACjB,aAAa,EACb,eAAe,EACf,QAAQ,GACT,MAAM,gBAAgB,CAAC"}

package/dist/game-theory/index.js

@@ -0,0 +1,47 @@
+"use strict";
+// ============================================================
+// Game theory — Punto de entrada público
+// ============================================================
+//
+// Computación de equilibria de Nash (puros y mixtos) para juegos
+// 2-player en forma normal NxM y juegos n-player simétricos chicos.
+//
+//   - findPureNash         enumera Nash puros exhaustivamente.
+//   - enumerateAllNash     enumera TODOS los Nash (puros y mixtos)
+//                          via support enumeration (2-player).
+//   - lemkeHowson          encuentra UN Nash via pivot LCP.
+//   - eliminateDominated   iterated elimination of dominated strats.
+//   - bestResponse         best responses puras dado un perfil mixto.
+//
+// Constructores ergonómicos: createTwoPlayerGame, prisonersDilemma,
+// rockPaperScissors, battleOfSexes, matchingPennies, stagHunt.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stagHunt = exports.matchingPennies = exports.battleOfSexes = exports.rockPaperScissors = exports.prisonersDilemma = exports.bestResponse = exports.eliminateDominated = exports.isDominated = exports.lemkeHowson = exports.enumerateAllNash = exports.findPureNash = exports.vectorsApproxEqual = exports.approxEqual = exports.expectedPayoff = exports.pureDistribution = exports.payoffOf = exports.totalProfiles = exports.indexToProfile = exports.profileToIndex = exports.createTwoPlayerGame = exports.createGame = void 0;
+var types_1 = require("./types");
+Object.defineProperty(exports, "createGame", { enumerable: true, get: function () { return types_1.createGame; } });
+Object.defineProperty(exports, "createTwoPlayerGame", { enumerable: true, get: function () { return types_1.createTwoPlayerGame; } });
+Object.defineProperty(exports, "profileToIndex", { enumerable: true, get: function () { return types_1.profileToIndex; } });
+Object.defineProperty(exports, "indexToProfile", { enumerable: true, get: function () { return types_1.indexToProfile; } });
+Object.defineProperty(exports, "totalProfiles", { enumerable: true, get: function () { return types_1.totalProfiles; } });
+Object.defineProperty(exports, "payoffOf", { enumerable: true, get: function () { return types_1.payoffOf; } });
+Object.defineProperty(exports, "pureDistribution", { enumerable: true, get: function () { return types_1.pureDistribution; } });
+Object.defineProperty(exports, "expectedPayoff", { enumerable: true, get: function () { return types_1.expectedPayoff; } });
+Object.defineProperty(exports, "approxEqual", { enumerable: true, get: function () { return types_1.approxEqual; } });
+Object.defineProperty(exports, "vectorsApproxEqual", { enumerable: true, get: function () { return types_1.vectorsApproxEqual; } });
+var pure_nash_1 = require("./pure-nash");
+Object.defineProperty(exports, "findPureNash", { enumerable: true, get: function () { return pure_nash_1.findPureNash; } });
+var support_enumeration_1 = require("./support-enumeration");
+Object.defineProperty(exports, "enumerateAllNash", { enumerable: true, get: function () { return support_enumeration_1.enumerateAllNash; } });
+var lemke_howson_1 = require("./lemke-howson");
+Object.defineProperty(exports, "lemkeHowson", { enumerable: true, get: function () { return lemke_howson_1.lemkeHowson; } });
+var dominance_1 = require("./dominance");
+Object.defineProperty(exports, "isDominated", { enumerable: true, get: function () { return dominance_1.isDominated; } });
+Object.defineProperty(exports, "eliminateDominated", { enumerable: true, get: function () { return dominance_1.eliminateDominated; } });
+Object.defineProperty(exports, "bestResponse", { enumerable: true, get: function () { return dominance_1.bestResponse; } });
+var common_games_1 = require("./common-games");
+Object.defineProperty(exports, "prisonersDilemma", { enumerable: true, get: function () { return common_games_1.prisonersDilemma; } });
+Object.defineProperty(exports, "rockPaperScissors", { enumerable: true, get: function () { return common_games_1.rockPaperScissors; } });
+Object.defineProperty(exports, "battleOfSexes", { enumerable: true, get: function () { return common_games_1.battleOfSexes; } });
+Object.defineProperty(exports, "matchingPennies", { enumerable: true, get: function () { return common_games_1.matchingPennies; } });
+Object.defineProperty(exports, "stagHunt", { enumerable: true, get: function () { return common_games_1.stagHunt; } });
+//# sourceMappingURL=index.js.map

package/dist/game-theory/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/game-theory/index.ts"],"names":[],"mappings":";AAAA,+DAA+D;AAC/D,yCAAyC;AACzC,+DAA+D;AAC/D,EAAE;AACF,iEAAiE;AACjE,oEAAoE;AACpE,EAAE;AACF,+DAA+D;AAC/D,mEAAmE;AACnE,+DAA+D;AAC/D,4DAA4D;AAC5D,qEAAqE;AACrE,sEAAsE;AACtE,EAAE;AACF,oEAAoE;AACpE,+DAA+D;;;AAG/D,iCAWiB;AAVf,mGAAA,UAAU,OAAA;AACV,4GAAA,mBAAmB,OAAA;AACnB,uGAAA,cAAc,OAAA;AACd,uGAAA,cAAc,OAAA;AACd,sGAAA,aAAa,OAAA;AACb,iGAAA,QAAQ,OAAA;AACR,yGAAA,gBAAgB,OAAA;AAChB,uGAAA,cAAc,OAAA;AACd,oGAAA,WAAW,OAAA;AACX,2GAAA,kBAAkB,OAAA;AAGpB,yCAA2C;AAAlC,yGAAA,YAAY,OAAA;AACrB,6DAAyD;AAAhD,uHAAA,gBAAgB,OAAA;AACzB,+CAA6C;AAApC,2GAAA,WAAW,OAAA;AAEpB,yCAA4E;AAAnE,wGAAA,WAAW,OAAA;AAAE,+GAAA,kBAAkB,OAAA;AAAE,yGAAA,YAAY,OAAA;AAEtD,+CAMwB;AALtB,gHAAA,gBAAgB,OAAA;AAChB,iHAAA,iBAAiB,OAAA;AACjB,6GAAA,aAAa,OAAA;AACb,+GAAA,eAAe,OAAA;AACf,wGAAA,QAAQ,OAAA"}

package/dist/game-theory/lemke-howson.d.ts

@@ -0,0 +1,3 @@
+import type { NashEquilibrium, NormalFormGame } from './types';
+export declare function lemkeHowson(game: NormalFormGame, startLabel?: number): NashEquilibrium | null;
+//# sourceMappingURL=lemke-howson.d.ts.map

package/dist/game-theory/lemke-howson.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lemke-howson.d.ts","sourceRoot":"","sources":["../../src/game-theory/lemke-howson.ts"],"names":[],"mappings":"AA8BA,OAAO,KAAK,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAK/D,wBAAgB,WAAW,CAAC,IAAI,EAAE,cAAc,EAAE,UAAU,SAAI,GAAG,eAAe,GAAG,IAAI,CAmQxF"}