Deploy plain static Space bundle

Replace broken Gradio Lite build with plain static JS bundle and remove stale public files.

README.md

@@ -12,7 +12,7 @@ pinned: false
 
 This Space is a compact public-facing demo for exploring 2x2 payoff matrices.
 
-It is packaged as a static Hugging Face Space using Gradio Lite, so the app runs client-side in the browser.
+It is packaged as a plain static Hugging Face Space, so the app runs client-side in the browser with no Python runtime and no Gradio dependency.
 
 It does three things:
 

app.mjs

@@ -0,0 +1,226 @@
+import {
+  PRESETS,
+  GAME_TYPE_COLORS,
+  GAME_TYPE_DESCRIPTIONS,
+  buildMatrix,
+  classifyFull,
+} from "./classifier.mjs";
+
+const INPUT_IDS = [
+  "r0c0_p1",
+  "r0c0_p2",
+  "r0c1_p1",
+  "r0c1_p2",
+  "r1c0_p1",
+  "r1c0_p2",
+  "r1c1_p1",
+  "r1c1_p2",
+];
+
+const DEFAULT_PRESET = "Prisoner's Dilemma";
+
+function init() {
+  const presetSelect = document.querySelector("#preset");
+  const analyzeButton = document.querySelector("#analyze");
+  const resetButton = document.querySelector("#reset");
+
+  for (const name of Object.keys(PRESETS)) {
+    const option = document.createElement("option");
+    option.value = name;
+    option.textContent = name;
+    presetSelect.append(option);
+  }
+
+  presetSelect.value = DEFAULT_PRESET;
+  applyPreset(DEFAULT_PRESET);
+
+  presetSelect.addEventListener("change", () => {
+    applyPreset(presetSelect.value);
+  });
+
+  analyzeButton.addEventListener("click", render);
+  resetButton.addEventListener("click", () => {
+    presetSelect.value = DEFAULT_PRESET;
+    applyPreset(DEFAULT_PRESET);
+  });
+
+  for (const inputId of INPUT_IDS) {
+    document.querySelector(`#${inputId}`).addEventListener("input", render);
+  }
+}
+
+function applyPreset(name) {
+  const values = PRESETS[name];
+  if (!values) {
+    return;
+  }
+
+  INPUT_IDS.forEach((inputId, index) => {
+    document.querySelector(`#${inputId}`).value = String(values[index]);
+  });
+
+  render();
+}
+
+function currentPayoffs() {
+  return INPUT_IDS.map((inputId) => {
+    const raw = document.querySelector(`#${inputId}`).value;
+    const parsed = Number.parseInt(raw, 10);
+    return Number.isNaN(parsed) ? 0 : parsed;
+  });
+}
+
+function render() {
+  const payoffs = currentPayoffs();
+  const matrix = buildMatrix(payoffs);
+  const result = classifyFull(matrix);
+
+  renderMatrix(matrix, result.ne);
+  renderSummary(matrix, result);
+  renderClassification(result);
+  renderProperties(result.props, result.ne);
+}
+
+function renderMatrix(matrix, equilibria) {
+  const neKeys = new Set(equilibria.map(([row, col]) => `${row}-${col}`));
+  const tbody = document.querySelector("#matrix-body");
+  tbody.innerHTML = "";
+
+  for (let row = 0; row < 2; row += 1) {
+    const tr = document.createElement("tr");
+    for (let col = 0; col < 2; col += 1) {
+      const td = document.createElement("td");
+      const [p1, p2] = matrix[row][col];
+      const isNe = neKeys.has(`${row}-${col}`);
+      td.className = isNe ? "matrix-cell is-ne" : "matrix-cell";
+      td.innerHTML = `
+        <div class="cell-coord">Row ${row} / Col ${col}</div>
+        <div class="cell-payoff">(${p1}, ${p2})</div>
+        <div class="cell-tag">${isNe ? "NASH EQUILIBRIUM" : " "}</div>
+      `;
+      tr.append(td);
+    }
+    tbody.append(tr);
+  }
+}
+
+function renderSummary(matrix, result) {
+  const summary = document.querySelector("#summary");
+  const positions = result.ne.map(([row, col]) => `(${row}, ${col})`).join(", ");
+
+  if (result.ne.length === 0) {
+    if (result.props.mixed_exists) {
+      summary.innerHTML = `
+        <div class="summary-line">Pure NE: none</div>
+        <div class="summary-line">Mixed NE: P1 Row 0 = <strong>${formatNumber(result.props.mixed_p)}</strong>, P2 Col 0 = <strong>${formatNumber(result.props.mixed_q)}</strong></div>
+        <div class="summary-line">Expected payoffs: <strong>(${formatNumber(result.props.mixed_payoff_p1)}, ${formatNumber(result.props.mixed_payoff_p2)})</strong></div>
+      `;
+      return;
+    }
+
+    summary.innerHTML = `
+      <div class="summary-line">Pure NE: none</div>
+      <div class="summary-line">Mixed NE: degenerate</div>
+    `;
+    return;
+  }
+
+  if (result.ne.length === 1) {
+    const [row, col] = result.ne[0];
+    summary.innerHTML = `
+      <div class="summary-line">Pure NE: <strong>1</strong></div>
+      <div class="summary-line">Position: <strong>(${row}, ${col})</strong></div>
+      <div class="summary-line">Payoffs: <strong>(${matrix[row][col][0]}, ${matrix[row][col][1]})</strong></div>
+    `;
+    return;
+  }
+
+  summary.innerHTML = `
+    <div class="summary-line">Pure NE: <strong>${result.ne.length}</strong></div>
+    <div class="summary-line">Positions: <strong>${positions}</strong></div>
+    <div class="summary-line">Best NE welfare: <strong>${Math.max(...result.props.ne_welfare)}</strong></div>
+  `;
+}
+
+function renderClassification(result) {
+  const label = result.label;
+  const badge = document.querySelector("#game-type-badge");
+  const desc = document.querySelector("#game-type-description");
+  const color = GAME_TYPE_COLORS[label] || "#7A7570";
+
+  badge.textContent = label;
+  badge.style.color = color;
+  badge.style.borderColor = color;
+  desc.textContent = GAME_TYPE_DESCRIPTIONS[label] || "";
+}
+
+function renderProperties(props, equilibria) {
+  const rows = [
+    propertyRow("P1 dominant strategy", boolBadge(props.p1_has_dominant), "weakly best in every column"),
+    propertyRow("P2 dominant strategy", boolBadge(props.p2_has_dominant), "weakly best in every row"),
+    propertyRow("Both dominant", boolBadge(props.both_dominant), ""),
+    propertyRow("Zero-sum", boolBadge(props.is_zero_sum), "payoff sum constant across cells"),
+    propertyRow("Symmetric", boolBadge(props.is_symmetric), "payoff swap across diagonal"),
+    propertyRow("Pure NE count", String(props.ne_count), equilibria.length ? formatPositions(equilibria) : "none"),
+    propertyRow("Any NE Pareto-dominated", boolBadge(props.has_pareto_dom_ne), ""),
+    propertyRow("All NE Pareto-efficient", boolBadge(props.all_ne_pareto_eff), ""),
+    propertyRow("Max social welfare", String(props.max_welfare), "best p1 + p2"),
+    propertyRow("NE welfare", props.ne_welfare.length ? props.ne_welfare.join(", ") : "-", ""),
+    propertyRow("Welfare loss", String(props.welfare_loss), "max welfare minus best NE welfare"),
+  ];
+
+  if (props.ne_count > 0) {
+    rows.push(
+      propertyRow("NE payoffs P1", props.ne_p1_payoffs.join(", "), "per equilibrium"),
+      propertyRow("NE payoffs P2", props.ne_p2_payoffs.join(", "), "per equilibrium"),
+      propertyRow("Payoff diff (P1-P2)", props.ne_payoff_diffs.join(", "), "per equilibrium"),
+      propertyRow("Any NE equal payoffs", boolBadge(props.ne_has_equal_payoffs), ""),
+      propertyRow("Mean abs diff at NE", props.ne_mean_abs_diff === null ? "-" : formatNumber(props.ne_mean_abs_diff), "")
+    );
+  }
+
+  if (props.ne_count === 0) {
+    if (props.mixed_exists) {
+      rows.push(
+        propertyRow("Mixed P1 plays Row 0", `p = ${formatNumber(props.mixed_p)}`, ""),
+        propertyRow("Mixed P2 plays Col 0", `q = ${formatNumber(props.mixed_q)}`, ""),
+        propertyRow(
+          "Mixed expected payoffs",
+          `(${formatNumber(props.mixed_payoff_p1)}, ${formatNumber(props.mixed_payoff_p2)})`,
+          ""
+        )
+      );
+    } else {
+      rows.push(propertyRow("Mixed strategy", "degenerate", "denominator zero"));
+    }
+  }
+
+  document.querySelector("#properties-body").innerHTML = rows.join("");
+}
+
+function propertyRow(label, value, note) {
+  return `
+    <tr>
+      <td>${label}</td>
+      <td>${value}</td>
+      <td>${note}</td>
+    </tr>
+  `;
+}
+
+function boolBadge(value) {
+  return `<span class="${value ? "bool-yes" : "bool-no"}">${value ? "YES" : "NO"}</span>`;
+}
+
+function formatPositions(positions) {
+  return positions.map(([row, col]) => `(${row}, ${col})`).join(", ");
+}
+
+function formatNumber(value) {
+  if (Number.isInteger(value)) {
+    return String(value);
+  }
+  return Number(value).toFixed(4).replace(/0+$/, "").replace(/\.$/, "");
+}
+
+init();

classifier.mjs

@@ -0,0 +1,399 @@
+export const PRESETS = {
+  "Prisoner's Dilemma": [3, 3, 0, 5, 5, 0, 1, 1],
+  "Stag Hunt": [4, 4, 1, 3, 3, 1, 2, 2],
+  "Chicken": [3, 3, 1, 4, 4, 1, 0, 0],
+  "Coordination Game": [2, 2, 0, 0, 0, 0, 2, 2],
+  "Battle of the Sexes": [3, 2, 0, 0, 0, 0, 2, 3],
+  "Matching Pennies": [1, -1, -1, 1, -1, 1, 1, -1],
+  "All Equal (4 NE)": [3, 3, 3, 3, 3, 3, 3, 3],
+};
+
+export const GAME_TYPE_COLORS = {
+  "Prisoner's Dilemma": "#E8610A",
+  Harmony: "#4CAF82",
+  Deadlock: "#C0392B",
+  "Battle of the Sexes": "#D97706",
+  "Stag Hunt": "#1D8A6B",
+  Chicken: "#C84B31",
+  Coordination: "#3A9BD5",
+  "Zero-Sum": "#9B59B6",
+  "Dominant (P1 only)": "#F39C12",
+  "Dominant (P2 only)": "#E67E22",
+  "No Equilibrium": "#7A7570",
+  Other: "#4A4540",
+};
+
+export const GAME_TYPE_DESCRIPTIONS = {
+  "Zero-Sum":
+    "A zero-sum game: one player's gain is exactly the other's loss. The total welfare is constant across all outcomes. Classic examples: chess, poker, matching pennies.",
+  "Prisoner's Dilemma":
+    "A social dilemma: both players have a dominant strategy, but the Nash equilibrium leaves both worse off than if they had cooperated. Rational individual behaviour produces a collectively suboptimal result.",
+  Harmony:
+    "A harmony game: both players have dominant strategies and the Nash equilibrium is Pareto-efficient. Rational self-interest aligns with the socially optimal outcome.",
+  Deadlock:
+    "Both players have dominant strategies leading to an equilibrium, but unlike the Prisoner's Dilemma the cooperative outcome is not better for both. Mutual defection is both rational and efficient.",
+  "Battle of the Sexes":
+    "An asymmetric coordination game with two diagonal equilibria. Both players want to coordinate, but each prefers a different equilibrium.",
+  "Stag Hunt":
+    "A symmetric coordination game with one high-reward cooperative equilibrium and one safer fallback equilibrium. Trust matters because failing to coordinate can be costly.",
+  Chicken:
+    "A symmetric anti-coordination game with off-diagonal equilibria. Each player wants the other side to yield, creating brinkmanship instead of stable mutual cooperation.",
+  Coordination:
+    "A coordination-style game: multiple Nash equilibria exist and the main strategic problem is choosing which stable outcome to coordinate on.",
+  "Dominant (P1 only)":
+    "Only Player 1 has a dominant strategy. Player 2's best response depends on what Player 1 does, but Player 1 always plays the same way.",
+  "Dominant (P2 only)":
+    "Only Player 2 has a dominant strategy. Player 1's best response depends on what Player 2 does, but Player 2 always plays the same way.",
+  "No Equilibrium":
+    "No pure-strategy Nash equilibrium exists. Best responses cycle, so the stable object is a mixed-strategy equilibrium.",
+  Other:
+    "A game that does not fit neatly into the classic taxonomy. Neither player has a dominant strategy and there is at least one pure-strategy Nash equilibrium.",
+};
+
+export function buildMatrix(payoffs) {
+  return [
+    [[payoffs[0], payoffs[1]], [payoffs[2], payoffs[3]]],
+    [[payoffs[4], payoffs[5]], [payoffs[6], payoffs[7]]],
+  ];
+}
+
+export function findNashEquilibria(matrix) {
+  const equilibria = [];
+  for (let row = 0; row < matrix.length; row += 1) {
+    for (let col = 0; col < matrix[row].length; col += 1) {
+      const p1 = matrix[row][col][0];
+      const p2 = matrix[row][col][1];
+
+      let rowBest = true;
+      for (let otherRow = 0; otherRow < matrix.length; otherRow += 1) {
+        if (matrix[otherRow][col][0] > p1) {
+          rowBest = false;
+          break;
+        }
+      }
+
+      let colBest = true;
+      for (let otherCol = 0; otherCol < matrix[row].length; otherCol += 1) {
+        if (matrix[row][otherCol][1] > p2) {
+          colBest = false;
+          break;
+        }
+      }
+
+      if (rowBest && colBest) {
+        equilibria.push([row, col]);
+      }
+    }
+  }
+  return equilibria;
+}
+
+function hasDominantStrategy(matrix, player) {
+  const rows = matrix.length;
+  const cols = matrix[0].length;
+
+  if (player === 0) {
+    for (let candidateRow = 0; candidateRow < rows; candidateRow += 1) {
+      let dominant = true;
+      for (let row = 0; row < rows; row += 1) {
+        for (let col = 0; col < cols; col += 1) {
+          if (matrix[candidateRow][col][0] < matrix[row][col][0]) {
+            dominant = false;
+            break;
+          }
+        }
+        if (!dominant) {
+          break;
+        }
+      }
+      if (dominant) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  for (let candidateCol = 0; candidateCol < cols; candidateCol += 1) {
+    let dominant = true;
+    for (let row = 0; row < rows; row += 1) {
+      for (let col = 0; col < cols; col += 1) {
+        if (matrix[row][candidateCol][1] < matrix[row][col][1]) {
+          dominant = false;
+          break;
+        }
+      }
+      if (!dominant) {
+        break;
+      }
+    }
+    if (dominant) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
+function paretoDominated(targetRow, targetCol, matrix) {
+  const hereP1 = matrix[targetRow][targetCol][0];
+  const hereP2 = matrix[targetRow][targetCol][1];
+
+  for (let row = 0; row < matrix.length; row += 1) {
+    for (let col = 0; col < matrix[row].length; col += 1) {
+      if (row === targetRow && col === targetCol) {
+        continue;
+      }
+      const thereP1 = matrix[row][col][0];
+      const thereP2 = matrix[row][col][1];
+      if (thereP1 >= hereP1 && thereP2 >= hereP2 && (thereP1 > hereP1 || thereP2 > hereP2)) {
+        return true;
+      }
+    }
+  }
+
+  return false;
+}
+
+export function computeMixedStrategy2x2(matrix) {
+  if (matrix.length !== 2 || matrix[0].length !== 2) {
+    return {
+      mixed_exists: false,
+      mixed_p: null,
+      mixed_q: null,
+      mixed_payoff_p1: null,
+      mixed_payoff_p2: null,
+    };
+  }
+
+  const a = Number(matrix[0][0][0]);
+  const e = Number(matrix[0][0][1]);
+  const b = Number(matrix[0][1][0]);
+  const f = Number(matrix[0][1][1]);
+  const c = Number(matrix[1][0][0]);
+  const g = Number(matrix[1][0][1]);
+  const d = Number(matrix[1][1][0]);
+  const h = Number(matrix[1][1][1]);
+
+  const denomP = e - g - f + h;
+  const denomQ = a - b - c + d;
+
+  if (denomP === 0 || denomQ === 0) {
+    return {
+      mixed_exists: false,
+      mixed_p: null,
+      mixed_q: null,
+      mixed_payoff_p1: null,
+      mixed_payoff_p2: null,
+    };
+  }
+
+  const eps = 1e-9;
+  let p = (h - g) / denomP;
+  let q = (d - b) / denomQ;
+
+  if (!(p >= -eps && p <= 1 + eps && q >= -eps && q <= 1 + eps)) {
+    return {
+      mixed_exists: false,
+      mixed_p: null,
+      mixed_q: null,
+      mixed_payoff_p1: null,
+      mixed_payoff_p2: null,
+    };
+  }
+
+  p = Math.max(0, Math.min(1, p));
+  q = Math.max(0, Math.min(1, q));
+
+  return {
+    mixed_exists: true,
+    mixed_p: round(p, 6),
+    mixed_q: round(q, 6),
+    mixed_payoff_p1: round(q * a + (1 - q) * b, 6),
+    mixed_payoff_p2: round(p * e + (1 - p) * g, 6),
+  };
+}
+
+function nePayoffStats(matrix, nePositions) {
+  if (nePositions.length === 0) {
+    return {
+      ne_p1_payoffs: [],
+      ne_p2_payoffs: [],
+      ne_payoff_diffs: [],
+      ne_has_equal_payoffs: false,
+      ne_mean_abs_diff: null,
+    };
+  }
+
+  const p1Payoffs = nePositions.map(([row, col]) => matrix[row][col][0]);
+  const p2Payoffs = nePositions.map(([row, col]) => matrix[row][col][1]);
+  const diffs = p1Payoffs.map((value, index) => value - p2Payoffs[index]);
+  const absMean = diffs.reduce((sum, diff) => sum + Math.abs(diff), 0) / diffs.length;
+
+  return {
+    ne_p1_payoffs: p1Payoffs,
+    ne_p2_payoffs: p2Payoffs,
+    ne_payoff_diffs: diffs,
+    ne_has_equal_payoffs: diffs.some((diff) => diff === 0),
+    ne_mean_abs_diff: absMean,
+  };
+}
+
+export function classifyProperties(matrix, nePositions) {
+  const p1Dominant = hasDominantStrategy(matrix, 0);
+  const p2Dominant = hasDominantStrategy(matrix, 1);
+
+  const sums = [];
+  let maxWelfare = -Infinity;
+  for (let row = 0; row < matrix.length; row += 1) {
+    for (let col = 0; col < matrix[row].length; col += 1) {
+      const welfare = matrix[row][col][0] + matrix[row][col][1];
+      sums.push(welfare);
+      if (welfare > maxWelfare) {
+        maxWelfare = welfare;
+      }
+    }
+  }
+  const isZeroSum = sums.every((value) => value === sums[0]);
+
+  let isSymmetric = matrix.length === matrix[0].length;
+  if (isSymmetric) {
+    for (let row = 0; row < matrix.length; row += 1) {
+      for (let col = 0; col < matrix[row].length; col += 1) {
+        if (matrix[row][col][0] !== matrix[col][row][1]) {
+          isSymmetric = false;
+          break;
+        }
+      }
+      if (!isSymmetric) {
+        break;
+      }
+    }
+  }
+
+  const neWelfare = nePositions.map(([row, col]) => matrix[row][col][0] + matrix[row][col][1]);
+  const maxNeWelfare = neWelfare.length > 0 ? Math.max(...neWelfare) : 0;
+  const welfareLoss = maxWelfare - maxNeWelfare;
+
+  const paretoFlags = nePositions.map(([row, col]) => paretoDominated(row, col, matrix));
+  const hasParetoDominatedNe = paretoFlags.some(Boolean);
+
+  const mixed = nePositions.length === 0 ? computeMixedStrategy2x2(matrix) : {
+    mixed_exists: false,
+    mixed_p: null,
+    mixed_q: null,
+    mixed_payoff_p1: null,
+    mixed_payoff_p2: null,
+  };
+
+  const asym = nePayoffStats(matrix, nePositions);
+
+  return {
+    p1_has_dominant: p1Dominant,
+    p2_has_dominant: p2Dominant,
+    both_dominant: p1Dominant && p2Dominant,
+    is_zero_sum: isZeroSum,
+    is_symmetric: isSymmetric,
+    ne_count: nePositions.length,
+    has_pareto_dom_ne: hasParetoDominatedNe,
+    all_ne_pareto_eff: !hasParetoDominatedNe,
+    max_welfare: maxWelfare,
+    ne_welfare: neWelfare,
+    welfare_loss: welfareLoss,
+    mixed_exists: mixed.mixed_exists,
+    mixed_p: mixed.mixed_p,
+    mixed_q: mixed.mixed_q,
+    mixed_payoff_p1: mixed.mixed_payoff_p1,
+    mixed_payoff_p2: mixed.mixed_payoff_p2,
+    ne_p1_payoffs: asym.ne_p1_payoffs,
+    ne_p2_payoffs: asym.ne_p2_payoffs,
+    ne_payoff_diffs: asym.ne_payoff_diffs,
+    ne_has_equal_payoffs: asym.ne_has_equal_payoffs,
+    ne_mean_abs_diff: asym.ne_mean_abs_diff,
+  };
+}
+
+function isDiagonalPair(nePositions) {
+  return nePositions.length === 2
+    && nePositions.some(([row, col]) => row === 0 && col === 0)
+    && nePositions.some(([row, col]) => row === 1 && col === 1);
+}
+
+function isOffDiagonalPair(nePositions) {
+  return nePositions.length === 2
+    && nePositions.some(([row, col]) => row === 0 && col === 1)
+    && nePositions.some(([row, col]) => row === 1 && col === 0);
+}
+
+export function classifyGameType(props, nePositions, matrix) {
+  if (props.is_zero_sum) {
+    return "Zero-Sum";
+  }
+
+  if (props.both_dominant) {
+    if (props.has_pareto_dom_ne && props.welfare_loss > 0) {
+      return "Prisoner's Dilemma";
+    }
+    if (props.welfare_loss === 0) {
+      return "Harmony";
+    }
+    return "Deadlock";
+  }
+
+  if (matrix && isDiagonalPair(nePositions)) {
+    const tl = matrix[0][0];
+    const br = matrix[1][1];
+
+    const p1PrefersTl = tl[0] > br[0];
+    const p1PrefersBr = br[0] > tl[0];
+    const p2PrefersTl = tl[1] > br[1];
+    const p2PrefersBr = br[1] > tl[1];
+
+    if ((p1PrefersTl && p2PrefersBr) || (p1PrefersBr && p2PrefersTl)) {
+      return "Battle of the Sexes";
+    }
+
+    if (props.is_symmetric) {
+      const tlWelfare = tl[0] + tl[1];
+      const brWelfare = br[0] + br[1];
+      if (tlWelfare !== brWelfare) {
+        return "Stag Hunt";
+      }
+    }
+
+    return "Coordination";
+  }
+
+  if (matrix && isOffDiagonalPair(nePositions) && props.is_symmetric) {
+    return "Chicken";
+  }
+
+  if (nePositions.length >= 2 && props.is_symmetric) {
+    return "Coordination";
+  }
+
+  if (props.p1_has_dominant && !props.p2_has_dominant) {
+    return "Dominant (P1 only)";
+  }
+
+  if (props.p2_has_dominant && !props.p1_has_dominant) {
+    return "Dominant (P2 only)";
+  }
+
+  if (props.ne_count === 0) {
+    return "No Equilibrium";
+  }
+
+  return "Other";
+}
+
+export function classifyFull(matrix) {
+  const ne = findNashEquilibria(matrix);
+  const props = classifyProperties(matrix, ne);
+  const label = classifyGameType(props, ne, matrix);
+  return { ne, props, label };
+}
+
+function round(value, digits) {
+  const factor = 10 ** digits;
+  return Math.round(value * factor) / factor;
+}

index.html

@@ -4,1476 +4,133 @@
     <meta charset="utf-8">
     <meta name="viewport" content="width=device-width, initial-scale=1">
     <title>Game Theory Matrix Classifier</title>
-    <meta name="description" content="Client-side 2x2 game theory matrix explorer and classifier built with Gradio Lite.">
-    <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/@gradio/lite/dist/lite.css">
-    <style>
-      html, body {
-        margin: 0;
-        min-height: 100%;
-        background: #0F0F0F;
-      }
-      body {
-        background:
-          radial-gradient(circle at top right, rgba(232, 97, 10, 0.12), transparent 28rem),
-          linear-gradient(180deg, #0F0F0F 0%, #120F0C 100%);
-      }
-    </style>
+    <meta
+      name="description"
+      content="Static 2x2 game theory matrix explorer with Nash equilibrium detection and classic game classification."
+    >
+    <link rel="preconnect" href="https://fonts.googleapis.com">
+    <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
+    <link href="https://fonts.googleapis.com/css2?family=IBM+Plex+Mono:wght@400;500&family=Space+Grotesk:wght@500;700&display=swap" rel="stylesheet">
+    <link rel="stylesheet" href="./styles.css">
   </head>
   <body>
-    <gradio-lite>
-      <gradio-requirements>
-numpy==2.2.6
-      </gradio-requirements>
-      <gradio-file name="app.py" entrypoint="true">
-&quot;&quot;&quot;
-app.py — Game Theory Matrix Classifier  ·  Gradio Lite source app
-──────────────────────────────────────────────────────────────────
-Used as the Python entrypoint embedded into the exported static HF Space.
-&quot;&quot;&quot;
-
-import sys
-from pathlib import Path
-
-import gradio as gr
-import numpy as np
-
-sys.path.insert(0, str(Path(__file__).parent))
-
-from src.matrix_permutations import find_nash_equilibria
-from src.analysis import classify_full, GAME_TYPE_DESCRIPTIONS
-from src.theme import (
-    GRADIO_CSS,
-    ACCENT, BG_PAGE, BG_SURFACE, BG_ALT,
-    BORDER_STRONG, TEXT_PRI, TEXT_MUT, TEXT_DIM,
-)
-
-
-PRESETS = {
-    &quot;Prisoner&#x27;s Dilemma&quot;: (3, 3, 0, 5, 5, 0, 1, 1),
-    &quot;Stag Hunt&quot;:          (4, 4, 1, 3, 3, 1, 2, 2),
-    &quot;Chicken&quot;:            (3, 3, 1, 4, 4, 1, 0, 0),
-    &quot;Coordination Game&quot;:  (2, 2, 0, 0, 0, 0, 2, 2),
-    &quot;Battle of the Sexes&quot;:(3, 2, 0, 0, 0, 0, 2, 3),
-    &quot;Matching Pennies&quot;:   (1, -1, -1, 1, -1, 1, 1, -1),
-    &quot;All Equal (4 NE)&quot;:   (3, 3, 3, 3, 3, 3, 3, 3),
-}
-
-GAME_TYPE_COLORS = {
-    &quot;Prisoner&#x27;s Dilemma&quot;: &quot;#E8610A&quot;,
-    &quot;Harmony&quot;:            &quot;#4CAF82&quot;,
-    &quot;Deadlock&quot;:           &quot;#C0392B&quot;,
-    &quot;Battle of the Sexes&quot;:&quot;#D97706&quot;,
-    &quot;Stag Hunt&quot;:          &quot;#1D8A6B&quot;,
-    &quot;Chicken&quot;:            &quot;#C84B31&quot;,
-    &quot;Coordination&quot;:       &quot;#3A9BD5&quot;,
-    &quot;Zero-Sum&quot;:           &quot;#9B59B6&quot;,
-    &quot;Dominant (P1 only)&quot;: &quot;#F39C12&quot;,
-    &quot;Dominant (P2 only)&quot;: &quot;#E67E22&quot;,
-    &quot;No Equilibrium&quot;:     &quot;#7A7570&quot;,
-    &quot;Other&quot;:              &quot;#4A4540&quot;,
-}
-
-
-def load_preset(name):
-    return PRESETS.get(name, (0,) * 8)
-
-
-def _parse(vals):
-    return [int(v) for v in vals]
-
-
-def _build_matrix(payoffs):
-    return np.array([
-        [[payoffs[0], payoffs[1]], [payoffs[2], payoffs[3]]],
-        [[payoffs[4], payoffs[5]], [payoffs[6], payoffs[7]]],
-    ], dtype=np.int32)
-
-
-def _matrix_html(payoffs, equilibria):
-    ne_set = set(equilibria)
-    rows_html = []
-    for r in range(2):
-        row_cells = []
-        for c in range(2):
-            idx = r * 2 + c
-            p1, p2 = payoffs[idx * 2], payoffs[idx * 2 + 1]
-            is_ne = (r, c) in ne_set
-            accent = f&quot;color:{ACCENT};font-weight:600;&quot; if is_ne else f&quot;color:{TEXT_MUT};&quot;
-            star = &quot; ★&quot; if is_ne else &quot;&quot;
-            row_cells.append(
-                f&quot;&lt;td style=&#x27;padding:14px 22px;border:1px solid {BORDER_STRONG};&quot;
-                f&quot;background:{BG_ALT};text-align:center;{accent}&#x27;&gt;&quot;
-                f&quot;({p1}, {p2}){star}&lt;/td&gt;&quot;
-            )
-        rows_html.append(&quot;&lt;tr&gt;&quot; + &quot;&quot;.join(row_cells) + &quot;&lt;/tr&gt;&quot;)
-
-    header = (
-        f&quot;&lt;tr&gt;&quot;
-        f&quot;&lt;th style=&#x27;padding:8px 22px;background:{BG_PAGE};color:{TEXT_DIM};&quot;
-        f&quot;font-size:0.75rem;text-transform:uppercase;border:1px solid {BORDER_STRONG}&#x27;&gt;Col 0&lt;/th&gt;&quot;
-        f&quot;&lt;th style=&#x27;padding:8px 22px;background:{BG_PAGE};color:{TEXT_DIM};&quot;
-        f&quot;font-size:0.75rem;text-transform:uppercase;border:1px solid {BORDER_STRONG}&#x27;&gt;Col 1&lt;/th&gt;&quot;
-        f&quot;&lt;/tr&gt;&quot;
-    )
-    return (
-        f&quot;&lt;table style=&#x27;border-collapse:collapse;font-family:IBM Plex Mono,monospace;&quot;
-        f&quot;font-size:1rem;margin:auto;&#x27;&gt;{header}{&#x27;&#x27;.join(rows_html)}&lt;/table&gt;&quot;
-    )
-
-
-def compute_nash(r0c0_p1, r0c0_p2, r0c1_p1, r0c1_p2,
-                 r1c0_p1, r1c0_p2, r1c1_p1, r1c1_p2):
-    payoffs = _parse([r0c0_p1, r0c0_p2, r0c1_p1, r0c1_p2,
-                      r1c0_p1, r1c0_p2, r1c1_p1, r1c1_p2])
-    matrix = _build_matrix(payoffs)
-    eq = find_nash_equilibria(matrix)
-
-    table_html = _matrix_html(payoffs, eq)
-
-    if not eq:
-        props, _ = classify_full(matrix, [])
-        if props[&quot;mixed_exists&quot;]:
-            p_val, q_val = props[&quot;mixed_p&quot;], props[&quot;mixed_q&quot;]
-            ep1, ep2 = props[&quot;mixed_payoff_p1&quot;], props[&quot;mixed_payoff_p2&quot;]
-            desc = (
-                f&quot;&lt;p style=&#x27;color:{TEXT_MUT};font-family:IBM Plex Mono,monospace;&#x27;&gt;&quot;
-                f&quot;⚠ &lt;strong style=&#x27;color:{TEXT_PRI}&#x27;&gt;No pure-strategy Nash equilibrium.&lt;/strong&gt;&lt;br&gt;&quot;
-                f&quot;Mixed-strategy NE: P1 plays Row&amp;nbsp;0 with probability &quot;
-                f&quot;&lt;strong style=&#x27;color:{ACCENT}&#x27;&gt;p&amp;nbsp;=&amp;nbsp;{p_val:.4f}&lt;/strong&gt;, &quot;
-                f&quot;P2 plays Col&amp;nbsp;0 with probability &quot;
-                f&quot;&lt;strong style=&#x27;color:{ACCENT}&#x27;&gt;q&amp;nbsp;=&amp;nbsp;{q_val:.4f}&lt;/strong&gt;.&lt;br&gt;&quot;
-                f&quot;Expected payoffs: ({ep1:.3f},&amp;nbsp;{ep2:.3f}).&lt;/p&gt;&quot;
-            )
-        else:
-            desc = (
-                f&quot;&lt;p style=&#x27;color:{TEXT_MUT};font-family:IBM Plex Mono,monospace;&#x27;&gt;&quot;
-                f&quot;⚠ &lt;strong style=&#x27;color:{TEXT_PRI}&#x27;&gt;No pure-strategy Nash equilibrium.&lt;/strong&gt; &quot;
-                f&quot;Mixed NE is degenerate for this matrix.&lt;/p&gt;&quot;
-            )
-    elif len(eq) == 1:
-        r, c = eq[0]
-        desc = (
-            f&quot;&lt;p style=&#x27;font-family:IBM Plex Mono,monospace;&#x27;&gt;&quot;
-            f&quot;✓ &lt;strong style=&#x27;color:{ACCENT}&#x27;&gt;1 Nash equilibrium&lt;/strong&gt; &quot;
-            f&quot;at position ({r}, {c}) — payoffs ({matrix[r,c,0]}, {matrix[r,c,1]}).&lt;/p&gt;&quot;
-        )
-    else:
-        pos_str = &quot;, &quot;.join(f&quot;({r},{c})&quot; for r, c in eq)
-        desc = (
-            f&quot;&lt;p style=&#x27;font-family:IBM Plex Mono,monospace;&#x27;&gt;&quot;
-            f&quot;✓ &lt;strong style=&#x27;color:{ACCENT}&#x27;&gt;{len(eq)} Nash equilibria&lt;/strong&gt; &quot;
-            f&quot;at positions: {pos_str}.&lt;/p&gt;&quot;
-        )
-
-    return (
-        f&quot;&lt;div style=&#x27;text-align:center;padding:1.5rem;&#x27;&gt;&quot;
-        f&quot;{table_html}&quot;
-        f&quot;&lt;div style=&#x27;margin-top:1rem;&#x27;&gt;{desc}&lt;/div&gt;&quot;
-        f&quot;&lt;/div&gt;&quot;
-    )
-
-
-def classify_matrix(r0c0_p1, r0c0_p2, r0c1_p1, r0c1_p2,
-                    r1c0_p1, r1c0_p2, r1c1_p1, r1c1_p2):
-    payoffs = _parse([r0c0_p1, r0c0_p2, r0c1_p1, r0c1_p2,
-                      r1c0_p1, r1c0_p2, r1c1_p1, r1c1_p2])
-    matrix = _build_matrix(payoffs)
-    ne = find_nash_equilibria(matrix)
-    props, label = classify_full(matrix, ne)
-
-    def _bool_badge(v):
-        color = ACCENT if v else TEXT_DIM
-        symbol = &quot;✓&quot; if v else &quot;✗&quot;
-        return (f&quot;&lt;span style=&#x27;color:{color};font-weight:600;&quot;
-                f&quot;font-family:IBM Plex Mono,monospace&#x27;&gt;{symbol}&lt;/span&gt;&quot;)
-
-    def _row(name, val_html, note=&quot;&quot;):
-        return (
-            f&quot;&lt;tr&gt;&quot;
-            f&quot;&lt;td style=&#x27;padding:6px 14px;color:{TEXT_MUT};font-size:0.82rem;&quot;
-            f&quot;font-family:IBM Plex Mono,monospace;border-bottom:1px solid {BORDER_STRONG}&#x27;&gt;{name}&lt;/td&gt;&quot;
-            f&quot;&lt;td style=&#x27;padding:6px 14px;text-align:center;&quot;
-            f&quot;border-bottom:1px solid {BORDER_STRONG}&#x27;&gt;{val_html}&lt;/td&gt;&quot;
-            f&quot;&lt;td style=&#x27;padding:6px 14px;color:{TEXT_DIM};font-size:0.78rem;&quot;
-            f&quot;border-bottom:1px solid {BORDER_STRONG}&#x27;&gt;{note}&lt;/td&gt;&quot;
-            f&quot;&lt;/tr&gt;&quot;
-        )
-
-    ne_str = str(ne) if ne else &quot;none&quot;
-    nw_str = str(props[&quot;ne_welfare&quot;]) if props[&quot;ne_welfare&quot;] else &quot;—&quot;
-
-    prop_rows = [
-        _row(&quot;P1 has dominant strategy&quot;, _bool_badge(props[&quot;p1_has_dominant&quot;]),
-             &quot;a row weakly best in every column&quot;),
-        _row(&quot;P2 has dominant strategy&quot;, _bool_badge(props[&quot;p2_has_dominant&quot;]),
-             &quot;a column weakly best in every row&quot;),
-        _row(&quot;Both dominant&quot;, _bool_badge(props[&quot;both_dominant&quot;])),
-        _row(&quot;Zero-sum&quot;, _bool_badge(props[&quot;is_zero_sum&quot;]),
-             &quot;p1+p2 constant across all cells&quot;),
-        _row(&quot;Symmetric&quot;, _bool_badge(props[&quot;is_symmetric&quot;]),
-             &quot;matrix[r,c,0] == matrix[c,r,1]&quot;),
-        _row(&quot;NE count&quot;,
-             f&quot;&lt;span style=&#x27;color:{TEXT_PRI};font-weight:600;&quot;
-             f&quot;font-family:IBM Plex Mono,monospace&#x27;&gt;{props[&#x27;ne_count&#x27;]}&lt;/span&gt;&quot;,
-             ne_str),
-        _row(&quot;Any NE Pareto-dominated&quot;, _bool_badge(props[&quot;has_pareto_dom_ne&quot;]),
-             &quot;some other cell beats the NE for both players&quot;),
-        _row(&quot;All NE Pareto-efficient&quot;, _bool_badge(props[&quot;all_ne_pareto_eff&quot;])),
-        _row(&quot;Max social welfare&quot;,
-             f&quot;&lt;span style=&#x27;color:{TEXT_PRI};font-family:IBM Plex Mono,monospace&#x27;&gt;&quot;
-             f&quot;{props[&#x27;max_welfare&#x27;]}&lt;/span&gt;&quot;, &quot;best possible p1+p2&quot;),
-        _row(&quot;NE welfare&quot;,
-             f&quot;&lt;span style=&#x27;color:{TEXT_PRI};font-family:IBM Plex Mono,monospace&#x27;&gt;&quot;
-             f&quot;{nw_str}&lt;/span&gt;&quot;),
-        _row(&quot;Welfare loss&quot;,
-             f&quot;&lt;span style=&#x27;color:{&#x27;#C0392B&#x27; if props[&#x27;welfare_loss&#x27;] &gt; 0 else &#x27;#4CAF82&#x27;};&quot;
-             f&quot;font-weight:600;font-family:IBM Plex Mono,monospace&#x27;&gt;{props[&#x27;welfare_loss&#x27;]}&lt;/span&gt;&quot;,
-             &quot;max_welfare − best NE welfare&quot;),
-    ]
-
-    if props[&quot;ne_count&quot;] &gt; 0:
-        mean_diff_str = (f&quot;{props[&#x27;ne_mean_abs_diff&#x27;]:.3f}&quot;
-                         if props[&quot;ne_mean_abs_diff&quot;] is not None else &quot;—&quot;)
-        prop_rows += [
-            _row(&quot;NE payoffs — P1&quot;,
-                 f&quot;&lt;span style=&#x27;color:{TEXT_PRI};font-family:IBM Plex Mono,monospace&#x27;&gt;&quot;
-                 f&quot;{props[&#x27;ne_p1_payoffs&#x27;]}&lt;/span&gt;&quot;, &quot;per equilibrium&quot;),
-            _row(&quot;NE payoffs — P2&quot;,
-                 f&quot;&lt;span style=&#x27;color:{TEXT_PRI};font-family:IBM Plex Mono,monospace&#x27;&gt;&quot;
-                 f&quot;{props[&#x27;ne_p2_payoffs&#x27;]}&lt;/span&gt;&quot;, &quot;per equilibrium&quot;),
-            _row(&quot;Payoff diff (P1−P2)&quot;,
-                 f&quot;&lt;span style=&#x27;color:{TEXT_PRI};font-family:IBM Plex Mono,monospace&#x27;&gt;&quot;
-                 f&quot;{props[&#x27;ne_payoff_diffs&#x27;]}&lt;/span&gt;&quot;, &quot;per equilibrium&quot;),
-            _row(&quot;Any NE with equal payoffs&quot;, _bool_badge(props[&quot;ne_has_equal_payoffs&quot;]),
-                 &quot;P1 == P2 at some NE&quot;),
-            _row(&quot;Mean |P1−P2| at NE&quot;,
-                 f&quot;&lt;span style=&#x27;color:{TEXT_PRI};font-family:IBM Plex Mono,monospace&#x27;&gt;&quot;
-                 f&quot;{mean_diff_str}&lt;/span&gt;&quot;, &quot;payoff asymmetry&quot;),
-        ]
-
-    if props[&quot;ne_count&quot;] == 0:
-        if props[&quot;mixed_exists&quot;]:
-            prop_rows += [
-                _row(&quot;Mixed strategy — P1 plays Row 0&quot;,
-                     f&quot;&lt;span style=&#x27;color:{ACCENT};font-weight:600;&quot;
-                     f&quot;font-family:IBM Plex Mono,monospace&#x27;&gt;p = {props[&#x27;mixed_p&#x27;]:.4f}&lt;/span&gt;&quot;,
-                     &quot;probability ∈ [0, 1]&quot;),
-                _row(&quot;Mixed strategy — P2 plays Col 0&quot;,
-                     f&quot;&lt;span style=&#x27;color:{ACCENT};font-weight:600;&quot;
-                     f&quot;font-family:IBM Plex Mono,monospace&#x27;&gt;q = {props[&#x27;mixed_q&#x27;]:.4f}&lt;/span&gt;&quot;,
-                     &quot;probability ∈ [0, 1]&quot;),
-                _row(&quot;Expected payoffs at mixed NE&quot;,
-                     f&quot;&lt;span style=&#x27;color:{TEXT_PRI};font-family:IBM Plex Mono,monospace&#x27;&gt;&quot;
-                     f&quot;({props[&#x27;mixed_payoff_p1&#x27;]:.3f}, {props[&#x27;mixed_payoff_p2&#x27;]:.3f})&lt;/span&gt;&quot;,
-                     &quot;(P1, P2)&quot;),
-            ]
-        else:
-            prop_rows.append(
-                _row(&quot;Mixed strategy&quot;,
-                     f&quot;&lt;span style=&#x27;color:{TEXT_DIM}&#x27;&gt;none (degenerate)&lt;/span&gt;&quot;,
-                     &quot;denominator = 0&quot;)
-            )
-
-    props_html = (
-        f&quot;&lt;div style=&#x27;background:{BG_SURFACE};border:1px solid {BORDER_STRONG};&quot;
-        f&quot;border-radius:6px;overflow:hidden;margin-top:0.5rem&#x27;&gt;&quot;
-        f&quot;&lt;table style=&#x27;width:100%;border-collapse:collapse&#x27;&gt;{&#x27;&#x27;.join(prop_rows)}&lt;/table&gt;&lt;/div&gt;&quot;
-    )
-
-    badge_color = GAME_TYPE_COLORS.get(label, TEXT_MUT)
-    game_type_html = (
-        f&quot;&lt;div style=&#x27;text-align:center;padding:1.5rem 1rem&#x27;&gt;&quot;
-        f&quot;&lt;div style=&#x27;font-family:IBM Plex Mono,monospace;font-size:0.72rem;&quot;
-        f&quot;color:{TEXT_DIM};text-transform:uppercase;letter-spacing:0.12em;&quot;
-        f&quot;margin-bottom:0.6rem&#x27;&gt;Game Type&lt;/div&gt;&quot;
-        f&quot;&lt;div style=&#x27;font-family:Space Grotesk,sans-serif;font-weight:700;&quot;
-        f&quot;font-size:2rem;color:{badge_color};letter-spacing:-0.01em&#x27;&gt;{label}&lt;/div&gt;&quot;
-        f&quot;&lt;/div&gt;&quot;
-    )
-
-    desc = GAME_TYPE_DESCRIPTIONS.get(label, &quot;&quot;)
-    desc_html = (
-        f&quot;&lt;div style=&#x27;background:{BG_ALT};border-left:3px solid {badge_color};&quot;
-        f&quot;padding:1rem 1.2rem;border-radius:0 6px 6px 0;margin-top:0.5rem;&quot;
-        f&quot;font-family:IBM Plex Mono,monospace;font-size:0.84rem;&quot;
-        f&quot;color:{TEXT_MUT};line-height:1.6&#x27;&gt;{desc}&lt;/div&gt;&quot;
-    ) if desc else &quot;&quot;
-
-    return props_html, game_type_html, desc_html
-
-
-def build_app():
-    with gr.Blocks(title=&quot;Game Theory Matrix Classifier&quot;) as demo:
-        gr.HTML(&quot;&quot;&quot;
-        &lt;div style=&quot;padding:1.8rem 1rem 0.5rem;border-bottom:1px solid #3D2418;&quot;&gt;
-          &lt;div style=&quot;font-family:&#x27;Space Grotesk&#x27;,sans-serif;font-weight:700;
-                      font-size:1.5rem;text-transform:uppercase;
-                      letter-spacing:-0.02em;color:#F0EDE8;&quot;&gt;
-            Game Theory Matrix Classifier
-          &lt;/div&gt;
-          &lt;div style=&quot;font-family:&#x27;IBM Plex Mono&#x27;,monospace;font-size:0.78rem;
-                      color:#7A7570;margin-top:0.25rem;&quot;&gt;
-            Compact 2x2 game-theory demo · equilibria, mixed strategies, and classic game labels
-          &lt;/div&gt;
-        &lt;/div&gt;
-        &quot;&quot;&quot;)
-
-        gr.Markdown(&quot;&quot;&quot;
-This public Space is the lightweight front-facing slice of a larger local research project.
-It focuses on one thing: helping you explore **2x2 payoff matrices** without exposing notebooks,
-write-ups, or large local datasets.
-
-What you can do here:
-
-1. Enter any 2x2 payoff matrix and find its pure-strategy Nash equilibria
-2. See the mixed-strategy equilibrium when no pure one exists
-3. Classify the matrix into familiar game types such as
-   `Prisoner&#x27;s Dilemma`, `Battle of the Sexes`, `Stag Hunt`, `Chicken`,
-   `Coordination`, `Zero-Sum`, and more
-
-Use **Tab 01** for fast equilibrium checks. Use **Tab 02** for the fuller structural readout:
-dominant strategies, Pareto efficiency, welfare loss, asymmetry at equilibrium, and the
-game-type label.
-        &quot;&quot;&quot;)
-
-        with gr.Tabs():
-            with gr.Tab(&quot;01 / MATRIX EXPLORER&quot;):
-                gr.Markdown(
-                    &quot;&gt; Enter any 2x2 payoff matrix. Each cell takes two numbers: &quot;
-                    &quot;**Player 1&#x27;s payoff** and **Player 2&#x27;s payoff**. Hit **Compute** &quot;
-                    &quot;to find all pure-strategy Nash equilibria instantly.\n\n&quot;
-                    &quot;Or load a classic game from the presets.&quot;
-                )
-
-                with gr.Row():
-                    preset_dd = gr.Dropdown(
-                        choices=list(PRESETS.keys()),
-                        label=&quot;Load a classic game&quot;,
-                        value=None,
-                    )
-
-                gr.HTML(
-                    &quot;&lt;div style=&#x27;padding:0.4rem 0;color:#4A4540;font-size:0.75rem;&quot;
-                    &quot;font-family:IBM Plex Mono,monospace;&#x27;&gt;&quot;
-                    &quot;Row labels → Row 0 / Row 1 &amp;nbsp;·&amp;nbsp; &quot;
-                    &quot;Column labels → Col 0 / Col 1&lt;/div&gt;&quot;
-                )
-
-                with gr.Row():
-                    with gr.Column():
-                        gr.HTML(&quot;&lt;div class=&#x27;section-num&#x27;&gt;TOP ROW&lt;/div&gt;&quot;)
-                        with gr.Row():
-                            r0c0_p1 = gr.Number(label=&quot;(0,0) P1&quot;, value=3, precision=0)
-                            r0c0_p2 = gr.Number(label=&quot;(0,0) P2&quot;, value=3, precision=0)
-                        with gr.Row():
-                            r0c1_p1 = gr.Number(label=&quot;(0,1) P1&quot;, value=0, precision=0)
-                            r0c1_p2 = gr.Number(label=&quot;(0,1) P2&quot;, value=5, precision=0)
-                    with gr.Column():
-                        gr.HTML(&quot;&lt;div class=&#x27;section-num&#x27;&gt;BOTTOM ROW&lt;/div&gt;&quot;)
-                        with gr.Row():
-                            r1c0_p1 = gr.Number(label=&quot;(1,0) P1&quot;, value=5, precision=0)
-                            r1c0_p2 = gr.Number(label=&quot;(1,0) P2&quot;, value=0, precision=0)
-                        with gr.Row():
-                            r1c1_p1 = gr.Number(label=&quot;(1,1) P1&quot;, value=1, precision=0)
-                            r1c1_p2 = gr.Number(label=&quot;(1,1) P2&quot;, value=1, precision=0)
-
-                compute_btn = gr.Button(&quot;⚡ Compute Nash Equilibria&quot;, variant=&quot;primary&quot;)
-                output_html = gr.HTML()
-
-                all_inputs = [r0c0_p1, r0c0_p2, r0c1_p1, r0c1_p2,
-                              r1c0_p1, r1c0_p2, r1c1_p1, r1c1_p2]
-
-                compute_btn.click(fn=compute_nash, inputs=all_inputs, outputs=output_html)
-                preset_dd.change(fn=load_preset, inputs=preset_dd, outputs=all_inputs)
-                demo.load(fn=compute_nash, inputs=all_inputs, outputs=output_html)
-
-            with gr.Tab(&quot;02 / CLASSIFICATION&quot;):
-                gr.Markdown(
-                    &quot;&gt; Classify any 2x2 matrix: game type label, boolean structural &quot;
-                    &quot;properties, Pareto efficiency, welfare loss, and mixed-strategy &quot;
-                    &quot;equilibrium when no pure NE exists.&quot;
-                )
-
-                with gr.Row():
-                    cl_preset_dd = gr.Dropdown(
-                        choices=list(PRESETS.keys()),
-                        label=&quot;Load a classic game&quot;,
-                        value=&quot;Prisoner&#x27;s Dilemma&quot;,
-                    )
-
-                with gr.Row():
-                    with gr.Column():
-                        gr.HTML(&quot;&lt;div class=&#x27;section-num&#x27;&gt;TOP ROW&lt;/div&gt;&quot;)
-                        with gr.Row():
-                            c2_r0c0_p1 = gr.Number(label=&quot;(0,0) P1&quot;, value=3, precision=0)
-                            c2_r0c0_p2 = gr.Number(label=&quot;(0,0) P2&quot;, value=3, precision=0)
-                        with gr.Row():
-                            c2_r0c1_p1 = gr.Number(label=&quot;(0,1) P1&quot;, value=0, precision=0)
-                            c2_r0c1_p2 = gr.Number(label=&quot;(0,1) P2&quot;, value=5, precision=0)
-                    with gr.Column():
-                        gr.HTML(&quot;&lt;div class=&#x27;section-num&#x27;&gt;BOTTOM ROW&lt;/div&gt;&quot;)
-                        with gr.Row():
-                            c2_r1c0_p1 = gr.Number(label=&quot;(1,0) P1&quot;, value=5, precision=0)
-                            c2_r1c0_p2 = gr.Number(label=&quot;(1,0) P2&quot;, value=0, precision=0)
-                        with gr.Row():
-                            c2_r1c1_p1 = gr.Number(label=&quot;(1,1) P1&quot;, value=1, precision=0)
-                            c2_r1c1_p2 = gr.Number(label=&quot;(1,1) P2&quot;, value=1, precision=0)
-
-                classify_btn = gr.Button(&quot;🔍 Classify Game&quot;, variant=&quot;primary&quot;)
-
-                c2_inputs = [c2_r0c0_p1, c2_r0c0_p2, c2_r0c1_p1, c2_r0c1_p2,
-                             c2_r1c0_p1, c2_r1c0_p2, c2_r1c1_p1, c2_r1c1_p2]
-
-                c2_game_type_html = gr.HTML()
-                c2_desc_html = gr.HTML()
-                c2_props_html = gr.HTML()
-
-                classify_btn.click(
-                    fn=classify_matrix,
-                    inputs=c2_inputs,
-                    outputs=[c2_props_html, c2_game_type_html, c2_desc_html],
-                )
-                cl_preset_dd.change(fn=load_preset, inputs=cl_preset_dd, outputs=c2_inputs)
-                demo.load(
-                    fn=classify_matrix,
-                    inputs=c2_inputs,
-                    outputs=[c2_props_html, c2_game_type_html, c2_desc_html],
-                )
-    return demo
-
-
-if __name__ == &quot;__main__&quot;:
-    app = build_app()
-    app.launch(theme=gr.themes.Base(), css=GRADIO_CSS)
-
-</gradio-file><gradio-file name="src/__init__.py">
-
-</gradio-file><gradio-file name="src/analysis.py">
-&quot;&quot;&quot;
-analysis.py — Game type classification for 2-player payoff matrices.
-
-Two-layer approach:
-  Layer 1 — classify_properties(matrix) → dict of boolean/numeric flags
-  Layer 2 — classify_game_type(props, ne_positions) → human-readable string label
-
-Both layers work on a single matrix (numpy array, shape (R, C, 2)).
-For bulk classification of large datasets, use classify_batch() which processes
-a numpy batch (N, R, C, 2) in vectorised operations where possible.
-
-Named game types (in priority order):
-  &quot;Zero-Sum&quot;             — payoffs sum to constant in every cell
-  &quot;Prisoner&#x27;s Dilemma&quot;   — both dominant strategies, NE is Pareto-dominated
-  &quot;Harmony&quot;              — both dominant strategies, NE is Pareto-efficient
-  &quot;Deadlock&quot;             — both dominant strategies, inefficient but not PD
-  &quot;Battle of the Sexes&quot;  — 2 diagonal NE, players prefer different ones
-  &quot;Stag Hunt&quot;            — symmetric coordination with a payoff-dominant diagonal
-  &quot;Chicken&quot;              — symmetric anti-coordination with off-diagonal NE
-  &quot;Coordination&quot;         — ≥2 NE with coordination structure not covered above
-  &quot;Dominant (P1 only)&quot;   — only Player 1 has dominant strategy
-  &quot;Dominant (P2 only)&quot;   — only Player 2 has dominant strategy
-  &quot;No Equilibrium&quot;       — no pure-strategy NE
-  &quot;Other&quot;                — everything else
-
-Usage
------
-    from src.analysis import classify_properties, classify_game_type
-    from src.matrix_permutations import find_nash_equilibria
-    import numpy as np
-
-    m = np.array([[[3,3],[0,5]],[[5,0],[1,1]]], dtype=np.int32)
-    ne = find_nash_equilibria(m)
-    props = classify_properties(m, ne)
-    label = classify_game_type(props, ne)   # → &quot;Prisoner&#x27;s Dilemma&quot;
-&quot;&quot;&quot;
-
-from __future__ import annotations
-from typing import Dict, List, Tuple, Any
-import numpy as np
-
-
-# ---------------------------------------------------------------------------
-# Type alias
-# ---------------------------------------------------------------------------
-
-Props = Dict[str, Any]
-
-
-# ---------------------------------------------------------------------------
-# Layer 1: Boolean + numeric properties for a single matrix
-# ---------------------------------------------------------------------------
-
-def _has_dominant_strategy(matrix: np.ndarray, player: int) -&gt; bool:
-    &quot;&quot;&quot;
-    Return True if `player` (0=row, 1=col) has a weakly dominant strategy.
-
-    A strategy s* weakly dominates all others if, for every possible opponent
-    strategy, s* gives at least as good a payoff as any other choice.
-
-    For the row player:  there exists row r* such that
-        matrix[r*, c, 0] &gt;= matrix[r, c, 0]  for ALL r, c
-
-    For the column player:  there exists col c* such that
-        matrix[r, c*, 1] &gt;= matrix[r, c, 1]  for ALL r, c
-    &quot;&quot;&quot;
-    R, C, _ = matrix.shape
-    payoffs = matrix[:, :, player]           # (R, C)
-
-    if player == 0:   # row player — look for a dominant row
-        for r_star in range(R):
-            if np.all(payoffs[r_star, :] &gt;= payoffs):
-                return True
-    else:             # col player — look for a dominant column
-        for c_star in range(C):
-            if np.all(payoffs[:, c_star][:, None] &gt;= payoffs):
-                return True
-    return False
-
-
-def _pareto_dominated(cell_r: int, cell_c: int, matrix: np.ndarray) -&gt; bool:
-    &quot;&quot;&quot;
-    Return True if cell (cell_r, cell_c) is Pareto-dominated by any other cell.
-
-    A cell X is Pareto-dominated by cell Y if:
-        Y gives at least as much to both players, and strictly more to at least one.
-    &quot;&quot;&quot;
-    p1_here = int(matrix[cell_r, cell_c, 0])
-    p2_here = int(matrix[cell_r, cell_c, 1])
-    R, C, _ = matrix.shape
-
-    for r in range(R):
-        for c in range(C):
-            if r == cell_r and c == cell_c:
-                continue
-            p1_there = int(matrix[r, c, 0])
-            p2_there = int(matrix[r, c, 1])
-            if p1_there &gt;= p1_here and p2_there &gt;= p2_here:
-                if p1_there &gt; p1_here or p2_there &gt; p2_here:
-                    return True
-    return False
-
-
-def _compute_mixed_strategy_2x2(matrix: np.ndarray) -&gt; Dict[str, Any]:
-    &quot;&quot;&quot;
-    Compute the mixed-strategy Nash equilibrium for a 2×2 payoff matrix.
-
-    Layout:
-        Row 0: [(a, e), (b, f)]   → matrix[0,0]=(a,e), matrix[0,1]=(b,f)
-        Row 1: [(c, g), (d, h)]   → matrix[1,0]=(c,g), matrix[1,1]=(d,h)
-
-    P1 mixes with probability p (plays Row 0), making P2 indifferent:
-        p·e + (1−p)·g = p·f + (1−p)·h  →  p = (h−g) / (e−g−f+h)
-
-    P2 mixes with probability q (plays Col 0), making P1 indifferent:
-        q·a + (1−q)·b = q·c + (1−q)·d  →  q = (d−b) / (a−b−c+d)
-
-    Returns a dict with keys:
-        mixed_exists     bool
-        mixed_p          float | None   P1 plays Row 0 with this probability
-        mixed_q          float | None   P2 plays Col 0 with this probability
-        mixed_payoff_p1  float | None   P1 expected payoff at mixed NE
-        mixed_payoff_p2  float | None   P2 expected payoff at mixed NE
-    &quot;&quot;&quot;
-    _null = {&quot;mixed_exists&quot;: False, &quot;mixed_p&quot;: None, &quot;mixed_q&quot;: None,
-             &quot;mixed_payoff_p1&quot;: None, &quot;mixed_payoff_p2&quot;: None}
-
-    if matrix.shape != (2, 2, 2):
-        return _null
-
-    a, e = float(matrix[0, 0, 0]), float(matrix[0, 0, 1])
-    b, f = float(matrix[0, 1, 0]), float(matrix[0, 1, 1])
-    c, g = float(matrix[1, 0, 0]), float(matrix[1, 0, 1])
-    d, h = float(matrix[1, 1, 0]), float(matrix[1, 1, 1])
-
-    denom_p = e - g - f + h   # denominator for p
-    denom_q = a - b - c + d   # denominator for q
-
-    if denom_p == 0.0 or denom_q == 0.0:
-        return _null
-
-    p = (h - g) / denom_p
-    q = (d - b) / denom_q
-
-    eps = 1e-9
-    if not (-eps &lt;= p &lt;= 1.0 + eps and -eps &lt;= q &lt;= 1.0 + eps):
-        return _null
-
-    # Clamp to [0, 1] to absorb floating-point edge cases
-    p = max(0.0, min(1.0, p))
-    q = max(0.0, min(1.0, q))
-
-    ep1 = round(q * a + (1.0 - q) * b, 6)
-    ep2 = round(p * e + (1.0 - p) * g, 6)
-
-    return {
-        &quot;mixed_exists&quot;:    True,
-        &quot;mixed_p&quot;:         round(p, 6),
-        &quot;mixed_q&quot;:         round(q, 6),
-        &quot;mixed_payoff_p1&quot;: ep1,
-        &quot;mixed_payoff_p2&quot;: ep2,
-    }
-
-
-def _ne_payoff_stats(
-    matrix: np.ndarray,
-    ne_positions: List[Tuple[int, int]],
-) -&gt; Dict[str, Any]:
-    &quot;&quot;&quot;
-    Compute per-NE payoff statistics for a single matrix.
-
-    Returns a dict with keys:
-        ne_p1_payoffs        list[int]   — P1 payoff at each NE
-        ne_p2_payoffs        list[int]   — P2 payoff at each NE
-        ne_payoff_diffs      list[int]   — (P1−P2) at each NE
-        ne_has_equal_payoffs bool        — True if any NE has P1 == P2
-        ne_mean_abs_diff     float|None  — mean |P1−P2| across all NE; None if no NE
-    &quot;&quot;&quot;
-    if not ne_positions:
-        return {
-            &quot;ne_p1_payoffs&quot;:        [],
-            &quot;ne_p2_payoffs&quot;:        [],
-            &quot;ne_payoff_diffs&quot;:      [],
-            &quot;ne_has_equal_payoffs&quot;: False,
-            &quot;ne_mean_abs_diff&quot;:     None,
-        }
-
-    p1_payoffs = [int(matrix[r, c, 0]) for r, c in ne_positions]
-    p2_payoffs = [int(matrix[r, c, 1]) for r, c in ne_positions]
-    diffs      = [p1 - p2 for p1, p2 in zip(p1_payoffs, p2_payoffs)]
-
-    return {
-        &quot;ne_p1_payoffs&quot;:        p1_payoffs,
-        &quot;ne_p2_payoffs&quot;:        p2_payoffs,
-        &quot;ne_payoff_diffs&quot;:      diffs,
-        &quot;ne_has_equal_payoffs&quot;: any(d == 0 for d in diffs),
-        &quot;ne_mean_abs_diff&quot;:     sum(abs(d) for d in diffs) / len(diffs),
-    }
-
-
-def classify_properties(
-    matrix: np.ndarray,
-    ne_positions: List[Tuple[int, int]],
-) -&gt; Props:
-    &quot;&quot;&quot;
-    Compute a dictionary of structural properties for a single payoff matrix.
-
-    Parameters
-    ----------
-    matrix       : np.ndarray, shape (R, C, 2)
-    ne_positions : list of (row, col) Nash equilibria (from find_nash_equilibria)
-
-    Returns
-    -------
-    props : dict with the following keys:
-
-      p1_has_dominant     bool       — P1 has a weakly dominant strategy
-      p2_has_dominant     bool       — P2 has a weakly dominant strategy
-      both_dominant       bool       — both players have dominant strategies
-      is_zero_sum         bool       — all cells: p1+p2 == constant
-      is_symmetric        bool       — matrix[r,c,0] == matrix[c,r,1] (requires R==C)
-      ne_count            int        — number of pure-strategy NE
-      has_pareto_dom_ne   bool       — any NE is Pareto-dominated by another cell
-      all_ne_pareto_eff   bool       — no NE is Pareto-dominated
-      max_welfare         int        — max(p1+p2) over all cells
-      ne_welfare          list       — p1+p2 at each NE position
-      welfare_loss        int        — max_welfare − max(ne_welfare); 0 means NE is optimal
-
-      mixed_exists        bool       — True if a valid mixed-strategy NE exists
-                                       (only computed for 2×2 matrices with 0 pure NE)
-      mixed_p             float|None — P1 plays Row 0 with this probability
-      mixed_q             float|None — P2 plays Col 0 with this probability
-      mixed_payoff_p1     float|None — P1 expected payoff at mixed NE
-      mixed_payoff_p2     float|None — P2 expected payoff at mixed NE
-
-      ne_p1_payoffs        list[int]  — P1 payoff at each NE (empty if no pure NE)
-      ne_p2_payoffs        list[int]  — P2 payoff at each NE
-      ne_payoff_diffs      list[int]  — (P1−P2) at each NE
-      ne_has_equal_payoffs bool       — True if any NE has P1 == P2
-      ne_mean_abs_diff     float|None — mean |P1−P2| across all NE; None if no pure NE
-    &quot;&quot;&quot;
-    R, C, _ = matrix.shape
-    p1 = matrix[:, :, 0]
-    p2 = matrix[:, :, 1]
-    welfare = p1 + p2                        # (R, C)
-
-    # Dominant strategies
-    p1_dom = _has_dominant_strategy(matrix, 0)
-    p2_dom = _has_dominant_strategy(matrix, 1)
-
-    # Zero-sum: all payoff sums identical
-    sums = (p1 + p2).ravel()
-    is_zero_sum = bool(np.all(sums == sums[0]))
-
-    # Symmetry: matrix[r,c,0] == matrix[c,r,1] (only meaningful for square)
-    if R == C:
-        is_sym = all(
-            int(matrix[r, c, 0]) == int(matrix[c, r, 1])
-            for r in range(R) for c in range(C)
-        )
-    else:
-        is_sym = False
-
-    # NE welfare
-    ne_w = [int(welfare[r, c]) for r, c in ne_positions]
-    max_w = int(welfare.max())
-    max_ne_w = max(ne_w) if ne_w else 0
-    w_loss = max_w - max_ne_w
-
-    # Pareto efficiency of each NE
-    ne_pareto_dom = [_pareto_dominated(r, c, matrix) for r, c in ne_positions]
-    has_pd_ne = any(ne_pareto_dom)
-    all_pe_ne = not has_pd_ne
-
-    # Mixed-strategy equilibrium — 2×2 matrices with 0 pure NE only
-    if R == 2 and C == 2 and len(ne_positions) == 0:
-        mixed = _compute_mixed_strategy_2x2(matrix)
-    else:
-        mixed = {&quot;mixed_exists&quot;: False, &quot;mixed_p&quot;: None, &quot;mixed_q&quot;: None,
-                 &quot;mixed_payoff_p1&quot;: None, &quot;mixed_payoff_p2&quot;: None}
-
-    # Payoff asymmetry at Nash equilibria
-    asym = _ne_payoff_stats(matrix, ne_positions)
-
-    return {
-        &quot;p1_has_dominant&quot;:     p1_dom,
-        &quot;p2_has_dominant&quot;:     p2_dom,
-        &quot;both_dominant&quot;:       p1_dom and p2_dom,
-        &quot;is_zero_sum&quot;:         is_zero_sum,
-        &quot;is_symmetric&quot;:        is_sym,
-        &quot;ne_count&quot;:            len(ne_positions),
-        &quot;has_pareto_dom_ne&quot;:   has_pd_ne,
-        &quot;all_ne_pareto_eff&quot;:   all_pe_ne,
-        &quot;max_welfare&quot;:         max_w,
-        &quot;ne_welfare&quot;:          ne_w,
-        &quot;welfare_loss&quot;:        w_loss,
-        # Mixed strategy
-        &quot;mixed_exists&quot;:        mixed[&quot;mixed_exists&quot;],
-        &quot;mixed_p&quot;:             mixed[&quot;mixed_p&quot;],
-        &quot;mixed_q&quot;:             mixed[&quot;mixed_q&quot;],
-        &quot;mixed_payoff_p1&quot;:     mixed[&quot;mixed_payoff_p1&quot;],
-        &quot;mixed_payoff_p2&quot;:     mixed[&quot;mixed_payoff_p2&quot;],
-        # Payoff asymmetry
-        &quot;ne_p1_payoffs&quot;:       asym[&quot;ne_p1_payoffs&quot;],
-        &quot;ne_p2_payoffs&quot;:       asym[&quot;ne_p2_payoffs&quot;],
-        &quot;ne_payoff_diffs&quot;:     asym[&quot;ne_payoff_diffs&quot;],
-        &quot;ne_has_equal_payoffs&quot;: asym[&quot;ne_has_equal_payoffs&quot;],
-        &quot;ne_mean_abs_diff&quot;:    asym[&quot;ne_mean_abs_diff&quot;],
-    }
-
-
-# ---------------------------------------------------------------------------
-# Layer 2: Named game type (derived from properties)
-# ---------------------------------------------------------------------------
-
-# Plain-English descriptions keyed by type label
-GAME_TYPE_DESCRIPTIONS: Dict[str, str] = {
-    &quot;Zero-Sum&quot;: (
-        &quot;A zero-sum game: one player&#x27;s gain is exactly the other&#x27;s loss. &quot;
-        &quot;The total welfare is constant across all outcomes. &quot;
-        &quot;Classic examples: chess, poker, matching pennies.&quot;
-    ),
-    &quot;Prisoner&#x27;s Dilemma&quot;: (
-        &quot;A social dilemma: both players have a dominant strategy (defect), &quot;
-        &quot;but the Nash equilibrium leaves both worse off than if they had &quot;
-        &quot;cooperated. Rational individual behaviour produces a collectively &quot;
-        &quot;suboptimal result. Welfare loss &gt; 0.&quot;
-    ),
-    &quot;Harmony&quot;: (
-        &quot;A harmony game: both players have dominant strategies AND the &quot;
-        &quot;Nash equilibrium is Pareto-efficient. Rational self-interest &quot;
-        &quot;happens to align with the socially optimal outcome — no dilemma.&quot;
-    ),
-    &quot;Deadlock&quot;: (
-        &quot;Both players have dominant strategies leading to an equilibrium, &quot;
-        &quot;but unlike the Prisoner&#x27;s Dilemma the cooperative outcome is not &quot;
-        &quot;better for both. Mutual defection is both rational and efficient.&quot;
-    ),
-    &quot;Battle of the Sexes&quot;: (
-        &quot;An asymmetric coordination game with two diagonal equilibria. &quot;
-        &quot;Both players want to coordinate, but each prefers a different &quot;
-        &quot;equilibrium, so the main challenge is choosing which outcome to meet at.&quot;
-    ),
-    &quot;Stag Hunt&quot;: (
-        &quot;A symmetric coordination game with one high-reward cooperative &quot;
-        &quot;equilibrium and one safer fallback equilibrium. Trust matters because &quot;
-        &quot;failing to coordinate can be costly.&quot;
-    ),
-    &quot;Chicken&quot;: (
-        &quot;A symmetric anti-coordination game with off-diagonal equilibria. &quot;
-        &quot;Each player wants the other side to yield, creating brinkmanship &quot;
-        &quot;instead of stable mutual cooperation.&quot;
-    ),
-    &quot;Coordination&quot;: (
-        &quot;A coordination-style game: multiple Nash equilibria exist and the &quot;
-        &quot;main strategic problem is choosing which stable outcome to coordinate on.&quot;
-    ),
-    &quot;Dominant (P1 only)&quot;: (
-        &quot;Only Player 1 has a dominant strategy. Player 2&#x27;s best response &quot;
-        &quot;depends on what Player 1 does, but P1 always plays the same way.&quot;
-    ),
-    &quot;Dominant (P2 only)&quot;: (
-        &quot;Only Player 2 has a dominant strategy. Player 1&#x27;s best response &quot;
-        &quot;depends on what Player 2 does, but P2 always plays the same way.&quot;
-    ),
-    &quot;No Equilibrium&quot;: (
-        &quot;No pure-strategy Nash equilibrium exists. Neither player has a &quot;
-        &quot;stable resting point; best responses cycle. A mixed-strategy &quot;
-        &quot;equilibrium always exists (Nash&#x27;s theorem) and is computed for &quot;
-        &quot;2×2 matrices — see the mixed-strategy properties below.&quot;
-    ),
-    &quot;Other&quot;: (
-        &quot;A game that doesn&#x27;t fit neatly into the classic taxonomy. &quot;
-        &quot;Neither player has a dominant strategy and there is at least one &quot;
-        &quot;pure-strategy Nash equilibrium.&quot;
-    ),
-}
-
-
-def _is_diagonal_pair(ne_positions: List[Tuple[int, int]]) -&gt; bool:
-    return set(ne_positions) == {(0, 0), (1, 1)}
-
-
-def _is_off_diagonal_pair(ne_positions: List[Tuple[int, int]]) -&gt; bool:
-    return set(ne_positions) == {(0, 1), (1, 0)}
-
-
-def classify_game_type(
-    props: Props,
-    ne_positions: List[Tuple[int, int]],
-    matrix: np.ndarray | None = None,
-) -&gt; str:
-    &quot;&quot;&quot;
-    Assign a named game type label based on the properties dict.
-
-    Checked in strict priority order — the first matching rule wins.
-    &quot;&quot;&quot;
-    if props[&quot;is_zero_sum&quot;]:
-        return &quot;Zero-Sum&quot;
-
-    if props[&quot;both_dominant&quot;]:
-        # True PD: the NE is Pareto-suboptimal AND achieves less than max welfare.
-        # (welfare_loss &gt; 0 rules out the edge case where one NE Pareto-dominates
-        # another NE but the dominant NE still achieves max social welfare.)
-        if props[&quot;has_pareto_dom_ne&quot;] and props[&quot;welfare_loss&quot;] &gt; 0:
-            return &quot;Prisoner&#x27;s Dilemma&quot;
-        elif props[&quot;welfare_loss&quot;] == 0:
-            return &quot;Harmony&quot;
-        else:
-            return &quot;Deadlock&quot;
-
-    if matrix is not None and len(ne_positions) == 2 and _is_diagonal_pair(ne_positions):
-        tl = matrix[0, 0]
-        br = matrix[1, 1]
-
-        p1_prefers_tl = int(tl[0]) &gt; int(br[0])
-        p1_prefers_br = int(br[0]) &gt; int(tl[0])
-        p2_prefers_tl = int(tl[1]) &gt; int(br[1])
-        p2_prefers_br = int(br[1]) &gt; int(tl[1])
-
-        if (p1_prefers_tl and p2_prefers_br) or (p1_prefers_br and p2_prefers_tl):
-            return &quot;Battle of the Sexes&quot;
-
-        if props[&quot;is_symmetric&quot;]:
-            tl_welfare = int(tl[0] + tl[1])
-            br_welfare = int(br[0] + br[1])
-            if tl_welfare != br_welfare:
-                return &quot;Stag Hunt&quot;
-
-        return &quot;Coordination&quot;
-
-    if matrix is not None and len(ne_positions) == 2 and _is_off_diagonal_pair(ne_positions):
-        if props[&quot;is_symmetric&quot;]:
-            return &quot;Chicken&quot;
-
-    if len(ne_positions) &gt;= 2 and props[&quot;is_symmetric&quot;]:
-        return &quot;Coordination&quot;
-
-    if props[&quot;p1_has_dominant&quot;] and not props[&quot;p2_has_dominant&quot;]:
-        return &quot;Dominant (P1 only)&quot;
-
-    if props[&quot;p2_has_dominant&quot;] and not props[&quot;p1_has_dominant&quot;]:
-        return &quot;Dominant (P2 only)&quot;
-
-    if props[&quot;ne_count&quot;] == 0:
-        return &quot;No Equilibrium&quot;
-
-    return &quot;Other&quot;
-
-
-def classify_full(
-    matrix: np.ndarray,
-    ne_positions: List[Tuple[int, int]],
-) -&gt; Tuple[Props, str]:
-    &quot;&quot;&quot;
-    Convenience wrapper: compute both layers and return (props, game_type).
-    &quot;&quot;&quot;
-    props = classify_properties(matrix, ne_positions)
-    label = classify_game_type(props, ne_positions, matrix)
-    return props, label
-
-
-# ---------------------------------------------------------------------------
-# Bulk classification (used by enrich_datasets.py)
-# ---------------------------------------------------------------------------
-
-def classify_rows_batch(
-    matrices_flat: np.ndarray,
-    ne_positions_list: List[List[Tuple[int, int]]],
-    rows: int,
-    cols: int,
-) -&gt; List[Dict[str, Any]]:
-    &quot;&quot;&quot;
-    Classify a list of matrices given their pre-computed NE positions.
-
-    Parameters
-    ----------
-    matrices_flat     : (N, rows*cols*2) array of int — payoff values flat
-    ne_positions_list : list of length N, each element a list of (r,c) NE positions
-    rows, cols        : matrix dimensions
-
-    Returns
-    -------
-    List of dicts, one per matrix, with keys:
-      p1_has_dominant, p2_has_dominant, both_dominant, is_zero_sum,
-      is_symmetric, has_pareto_dom_ne, all_ne_pareto_eff,
-      max_welfare, ne_welfare, welfare_loss,
-      mixed_exists, mixed_p, mixed_q, mixed_payoff_p1, mixed_payoff_p2,
-      ne_p1_payoffs, ne_p2_payoffs, ne_payoff_diffs,
-      ne_has_equal_payoffs, ne_mean_abs_diff,
-      game_type
-    &quot;&quot;&quot;
-    results = []
-    for i, flat in enumerate(matrices_flat):
-        matrix = flat.reshape(rows, cols, 2)
-        ne = ne_positions_list[i]
-        props, label = classify_full(matrix, ne)
-        results.append({**props, &quot;game_type&quot;: label})
-    return results
-
-</gradio-file><gradio-file name="src/matrix_permutations.py">
-import itertools
-import numpy as np
-import csv
-from typing import List, Tuple, Iterator, Generator
-
-
-# ---------------------------------------------------------------------------
-# Core n×m generation
-# ---------------------------------------------------------------------------
-
-def generate_dual_matrices(rows: int, cols: int, min_val: int = 0, max_val: int = 5) -&gt; List[np.ndarray]:
-    &quot;&quot;&quot;
-    Generate ALL possible n×m matrices where every cell holds a (player1, player2)
-    payoff pair.  Both payoffs range from min_val to max_val inclusive.
-
-    Returns a list of numpy arrays with shape (rows, cols, 2).
-
-    Use generate_dual_matrices_iter() instead when the full list would be too
-    large to hold in RAM (e.g. 0-10 range with 214M matrices).
-    &quot;&quot;&quot;
-    values = range(min_val, max_val + 1)
-    position_pairs = list(itertools.product(values, values))
-    num_cells = rows * cols
-
-    matrices = []
-    for perm in itertools.product(position_pairs, repeat=num_cells):
-        matrix = np.array(perm, dtype=np.int32).reshape(rows, cols, 2)
-        matrices.append(matrix)
-    return matrices
-
-
-def generate_dual_matrices_iter(
-    rows: int, cols: int, min_val: int = 0, max_val: int = 5
-) -&gt; Iterator[np.ndarray]:
-    &quot;&quot;&quot;
-    Generator version of generate_dual_matrices().
-    Yields one (rows, cols, 2) numpy array at a time — never holds the full
-    dataset in memory.  Use this for large ranges (e.g. 0–10).
-    &quot;&quot;&quot;
-    values = range(min_val, max_val + 1)
-    position_pairs = list(itertools.product(values, values))
-    num_cells = rows * cols
-
-    for perm in itertools.product(position_pairs, repeat=num_cells):
-        yield np.array(perm, dtype=np.int32).reshape(rows, cols, 2)
-
-
-def generate_dual_matrices_batched(
-    rows: int,
-    cols: int,
-    min_val: int = 0,
-    max_val: int = 5,
-    batch_size: int = 50_000,
-) -&gt; Generator[np.ndarray, None, None]:
-    &quot;&quot;&quot;
-    Yields batches of matrices as a single numpy array of shape (B, rows, cols, 2).
-
-    B = batch_size for all batches except possibly the last one.
-    This is the most efficient input form for find_nash_batch_vectorized().
-
-    Example
-    -------
-    for batch in generate_dual_matrices_batched(2, 2, 0, 5, batch_size=50_000):
-        is_ne, counts = find_nash_batch_vectorized(batch)
-        # batch.shape == (50_000, 2, 2, 2) for all but the last chunk
-    &quot;&quot;&quot;
-    values = range(min_val, max_val + 1)
-    position_pairs = list(itertools.product(values, values))
-    num_cells = rows * cols
-    buf: list[np.ndarray] = []
-
-    for perm in itertools.product(position_pairs, repeat=num_cells):
-        buf.append(np.array(perm, dtype=np.int32))
-        if len(buf) == batch_size:
-            yield np.stack(buf).reshape(batch_size, rows, cols, 2)
-            buf = []
-
-    if buf:
-        n = len(buf)
-        yield np.stack(buf).reshape(n, rows, cols, 2)
-
-
-# ---------------------------------------------------------------------------
-# Nash equilibrium analysis — single matrix (Python loops)
-# ---------------------------------------------------------------------------
-
-def check_nash_equilibrium(matrix: np.ndarray, position: Tuple[int, int]) -&gt; bool:
-    &quot;&quot;&quot;
-    Return True if (row, col) is a pure-strategy Nash equilibrium.
-
-    A cell is a NE when:
-      - The row player cannot improve their payoff by switching to any other row
-        (keeping the column fixed).
-      - The column player cannot improve their payoff by switching to any other
-        column (keeping the row fixed).
-
-    Works for any n×m matrix shape.
-    &quot;&quot;&quot;
-    row, col = position
-    current_row_payoff = int(matrix[row, col, 0])
-    current_col_payoff = int(matrix[row, col, 1])
-
-    # Can the row player do better by moving to a different row?
-    for other_row in range(matrix.shape[0]):
-        if other_row != row and int(matrix[other_row, col, 0]) &gt; current_row_payoff:
-            return False
-
-    # Can the column player do better by moving to a different column?
-    for other_col in range(matrix.shape[1]):
-        if other_col != col and int(matrix[row, other_col, 1]) &gt; current_col_payoff:
-            return False
-
-    return True
-
-
-def find_nash_equilibria(matrix: np.ndarray) -&gt; List[Tuple[int, int]]:
-    &quot;&quot;&quot;
-    Find all pure-strategy Nash equilibria in an n×m payoff matrix.
-    Returns a (possibly empty) list of (row, col) positions.
-    &quot;&quot;&quot;
-    equilibria = []
-    for row in range(matrix.shape[0]):
-        for col in range(matrix.shape[1]):
-            if check_nash_equilibrium(matrix, (row, col)):
-                equilibria.append((row, col))
-    return equilibria
-
-
-# ---------------------------------------------------------------------------
-# Nash equilibrium analysis — vectorised batch (numpy, no Python loops)
-# ---------------------------------------------------------------------------
-
-def find_nash_batch_vectorized(
-    batch: np.ndarray,
-) -&gt; Tuple[np.ndarray, np.ndarray]:
-    &quot;&quot;&quot;
-    Find pure-strategy Nash equilibria for a BATCH of matrices in one numpy call.
-
-    Parameters
-    ----------
-    batch : np.ndarray, shape (N, rows, cols, 2)
-        N matrices, each of shape (rows, cols, 2) where the last axis is
-        [player1_payoff, player2_payoff].
-
-    Returns
-    -------
-    is_ne : np.ndarray, shape (N, rows, cols), dtype bool
-        True wherever a cell is a Nash equilibrium.
-    ne_counts : np.ndarray, shape (N,), dtype int
-        Number of Nash equilibria per matrix.
-
-    How it works
-    ------------
-    A cell (r, c) in matrix n is a NE when:
-      • P1 cannot strictly improve by switching rows:
-            p1[n, r, c] == max over r&#x27; of p1[n, r&#x27;, c]
-      • P2 cannot strictly improve by switching columns:
-            p2[n, r, c] == max over c&#x27; of p2[n, r, c&#x27;]
-
-    Both conditions are expressed as a single element-wise equality after
-    broadcasting the per-column and per-row maxima — no Python loops needed.
-
-    This is equivalent to find_nash_equilibria() but ~10–15× faster when
-    processing large batches (e.g. 50 000 matrices at a time).
-    &quot;&quot;&quot;
-    p1 = batch[:, :, :, 0]                          # (N, R, C)
-    p2 = batch[:, :, :, 1]                          # (N, R, C)
-
-    # Best P1 can achieve in each column (broadcast over rows dimension)
-    p1_col_max = p1.max(axis=1, keepdims=True)      # (N, 1, C)
-    # Best P2 can achieve in each row (broadcast over cols dimension)
-    p2_row_max = p2.max(axis=2, keepdims=True)      # (N, R, 1)
-
-    # A cell is NE iff both players are already at their column/row maximum
-    is_ne = (p1 == p1_col_max) &amp; (p2 == p2_row_max)  # (N, R, C)
-    ne_counts = is_ne.sum(axis=(1, 2)).astype(np.int32)  # (N,)
-
-    return is_ne, ne_counts
-
-
-# ---------------------------------------------------------------------------
-# CSV I/O
-# ---------------------------------------------------------------------------
-
-def _build_headers(rows: int, cols: int) -&gt; List[str]:
-    &quot;&quot;&quot;Return column headers for a rows×cols payoff matrix CSV.&quot;&quot;&quot;
-    headers = []
-    for r in range(rows):
-        for c in range(cols):
-            headers += [f&quot;r{r}c{c}_p1&quot;, f&quot;r{r}c{c}_p2&quot;]
-    headers += [&quot;num_equilibria&quot;, &quot;equilibrium_positions&quot;, &quot;category&quot;]
-    return headers
-
-
-def save_dual_matrices_to_csv(matrices: List[np.ndarray], filename: str) -&gt; None:
-    &quot;&quot;&quot;
-    Analyse each matrix for Nash equilibria and write results to a CSV file.
-
-    CSV columns (2×2 example):
-        r0c0_p1, r0c0_p2, r0c1_p1, r0c1_p2,
-        r1c0_p1, r1c0_p2, r1c1_p1, r1c1_p2,
-        num_equilibria, equilibrium_positions, category
-
-    Args:
-        matrices: list of numpy arrays with shape (rows, cols, 2)
-        filename: output CSV path
-    &quot;&quot;&quot;
-    if not matrices:
-        return
-
-    rows, cols = matrices[0].shape[0], matrices[0].shape[1]
-    headers = _build_headers(rows, cols)
-
-    with open(filename, &quot;w&quot;, newline=&quot;&quot;) as f:
-        writer = csv.writer(f)
-        writer.writerow(headers)
-        for matrix in matrices:
-            _write_matrix_row(writer, matrix)
-
-
-def save_dual_matrices_iter_to_csv(
-    matrix_iter: Iterator[np.ndarray],
-    filename: str,
-    rows: int,
-    cols: int,
-    progress_interval: int = 1_000_000,
-) -&gt; int:
-    &quot;&quot;&quot;
-    Stream matrices from an iterator directly into a CSV — constant RAM usage
-    regardless of dataset size.  Prints progress every progress_interval rows.
-
-    Returns the total number of matrices written.
-    &quot;&quot;&quot;
-    headers = _build_headers(rows, cols)
-    count = 0
-
-    with open(filename, &quot;w&quot;, newline=&quot;&quot;) as f:
-        writer = csv.writer(f)
-        writer.writerow(headers)
-        for matrix in matrix_iter:
-            _write_matrix_row(writer, matrix)
-            count += 1
-            if count % progress_interval == 0:
-                print(f&quot;  {count:,} matrices written…&quot;)
-
-    return count
-
-
-def save_batched_to_csv(
-    rows: int,
-    cols: int,
-    min_val: int,
-    max_val: int,
-    filename: str,
-    batch_size: int = 50_000,
-    progress_interval: int = 1_000_000,
-) -&gt; int:
-    &quot;&quot;&quot;
-    Generate all matrices for (rows, cols, min_val, max_val) and write to CSV
-    using batched vectorised NE detection.  Streams to disk — constant RAM.
-
-    Significantly faster than save_dual_matrices_iter_to_csv() for large ranges.
-    Returns total number of matrices written.
-    &quot;&quot;&quot;
-    headers = _build_headers(rows, cols)
-    count = 0
-
-    with open(filename, &quot;w&quot;, newline=&quot;&quot;) as f:
-        writer = csv.writer(f)
-        writer.writerow(headers)
-
-        for batch in generate_dual_matrices_batched(rows, cols, min_val, max_val, batch_size):
-            is_ne, ne_counts = find_nash_batch_vectorized(batch)
-            B = len(batch)
-
-            for i in range(B):
-                flat = batch[i].reshape(-1).tolist()
-                n_eq = int(ne_counts[i])
-                positions = [
-                    (r, c)
-                    for r in range(rows)
-                    for c in range(cols)
-                    if is_ne[i, r, c]
-                ]
-                category = &quot;Solved&quot; if n_eq &gt; 0 else &quot;Unsolved&quot;
-                writer.writerow(
-                    flat + [n_eq, str(positions) if positions else &quot;None&quot;, category]
-                )
-                count += 1
-                if count % progress_interval == 0:
-                    print(f&quot;  {count:,} matrices written…&quot;)
-
-    return count
-
-
-def _write_matrix_row(writer: csv.writer, matrix: np.ndarray) -&gt; None:
-    &quot;&quot;&quot;Write one matrix as a CSV row (helper used by both save functions).&quot;&quot;&quot;
-    flat_values = matrix.reshape(-1).tolist()
-    equilibria = find_nash_equilibria(matrix)
-    category = &quot;Solved&quot; if equilibria else &quot;Unsolved&quot;
-    writer.writerow(
-        flat_values
-        + [len(equilibria), str(equilibria) if equilibria else &quot;None&quot;, category]
-    )
-
-
-# ---------------------------------------------------------------------------
-# Display utilities
-# ---------------------------------------------------------------------------
-
-def print_dual_matrices(matrices: List[np.ndarray]) -&gt; None:
-    &quot;&quot;&quot;Print matrices in a human-readable format.&quot;&quot;&quot;
-    for i, matrix in enumerate(matrices):
-        print(f&quot;Matrix {i + 1}:&quot;)
-        for row in matrix:
-            print([f&quot;({pair[0]},{pair[1]})&quot; for pair in row])
-        print()
-
-
-# ---------------------------------------------------------------------------
-# Backwards-compatibility aliases
-# ---------------------------------------------------------------------------
-
-def generate_2x2_dual_matrices(min_val: int = 0, max_val: int = 5) -&gt; List[np.ndarray]:
-    &quot;&quot;&quot;Alias for generate_dual_matrices(2, 2, ...) — kept for compatibility.&quot;&quot;&quot;
-    return generate_dual_matrices(2, 2, min_val, max_val)
-
-</gradio-file><gradio-file name="src/theme.py">
-&quot;&quot;&quot;
-theme.py — UI theme tokens for the public Hugging Face Space.
-&quot;&quot;&quot;
-
-BG_PAGE       = &quot;#0F0F0F&quot;
-BG_SURFACE    = &quot;#1A1410&quot;
-BG_ALT        = &quot;#15110D&quot;
-
-BORDER_STRONG = &quot;#3D2418&quot;
-BORDER_SOFT   = &quot;#2A2520&quot;
-
-ACCENT        = &quot;#E8610A&quot;
-ACCENT_DIM    = &quot;#8C3A06&quot;
-
-TEXT_PRI      = &quot;#F0EDE8&quot;
-TEXT_MUT      = &quot;#7A7570&quot;
-TEXT_DIM      = &quot;#4A4540&quot;
-
-
-GRADIO_CSS = &quot;&quot;&quot;
-@import url(&#x27;https://fonts.googleapis.com/css2?family=Space+Grotesk:wght@600;700&amp;family=IBM+Plex+Mono:wght@400;500&amp;display=swap&#x27;);
-
-:root {
-  --bg-page:       #0F0F0F;
-  --bg-surface:    #1A1410;
-  --bg-alt:        #15110D;
-  --border-strong: #3D2418;
-  --border-soft:   #2A2520;
-  --accent:        #E8610A;
-  --accent-dim:    #8C3A06;
-  --text-pri:      #F0EDE8;
-  --text-mut:      #7A7570;
-  --text-dim:      #4A4540;
-  --radius:        6px;
-}
-
-body, .gradio-container {
-  background-color: var(--bg-page) !important;
-  color: var(--text-pri) !important;
-  font-family: &#x27;IBM Plex Mono&#x27;, &#x27;Courier New&#x27;, monospace !important;
-}
-
-h1, h2, h3, h4, .section-label {
-  font-family: &#x27;Space Grotesk&#x27;, sans-serif !important;
-  font-weight: 700 !important;
-  text-transform: uppercase !important;
-  letter-spacing: -0.02em !important;
-  color: var(--text-pri) !important;
-}
-
-.section-num {
-  color: var(--accent) !important;
-  font-family: &#x27;Space Grotesk&#x27;, sans-serif !important;
-  font-weight: 700 !important;
-  font-size: 0.75rem !important;
-  text-transform: uppercase !important;
-  letter-spacing: 0.12em !important;
-}
-
-.block, .panel, .gr-box, .gr-form {
-  background-color: var(--bg-surface) !important;
-  border: 1px solid var(--border-strong) !important;
-  border-radius: var(--radius) !important;
-}
-
-.tabs &gt; .tab-nav {
-  background-color: var(--bg-alt) !important;
-  border-bottom: 1px solid var(--border-strong) !important;
-}
-
-.tabs &gt; .tab-nav &gt; button {
-  color: var(--text-mut) !important;
-  font-family: &#x27;IBM Plex Mono&#x27;, monospace !important;
-  font-size: 0.78rem !important;
-  text-transform: uppercase !important;
-  letter-spacing: 0.08em !important;
-  border-bottom: 2px solid transparent !important;
-  padding: 0.55rem 1.1rem !important;
-  background: transparent !important;
-  transition: color 0.15s, border-color 0.15s;
-}
-
-.tabs &gt; .tab-nav &gt; button.selected,
-.tabs &gt; .tab-nav &gt; button:hover {
-  color: var(--accent) !important;
-  border-bottom-color: var(--accent) !important;
-}
-
-input, textarea, select, .gr-input, .gr-textbox {
-  background-color: var(--bg-alt) !important;
-  border: 1px solid var(--border-strong) !important;
-  color: var(--text-pri) !important;
-  border-radius: var(--radius) !important;
-  font-family: &#x27;IBM Plex Mono&#x27;, monospace !important;
-}
-
-input:focus, textarea:focus {
-  border-color: var(--accent) !important;
-  outline: none !important;
-  box-shadow: 0 0 0 2px rgba(232, 97, 10, 0.25) !important;
-}
-
-button.primary, .gr-button-primary {
-  background-color: var(--accent) !important;
-  color: #fff !important;
-  border: none !important;
-  border-radius: var(--radius) !important;
-  font-family: &#x27;IBM Plex Mono&#x27;, monospace !important;
-  font-weight: 500 !important;
-  letter-spacing: 0.04em !important;
-  transition: background-color 0.15s;
-}
-
-button.primary:hover {
-  background-color: var(--accent-dim) !important;
-}
-
-button.secondary, .gr-button-secondary {
-  background-color: transparent !important;
-  color: var(--text-mut) !important;
-  border: 1px solid var(--border-strong) !important;
-  border-radius: var(--radius) !important;
-  font-family: &#x27;IBM Plex Mono&#x27;, monospace !important;
-}
-
-button.secondary:hover {
-  border-color: var(--accent) !important;
-  color: var(--accent) !important;
-}
-
-table, .gr-dataframe table {
-  background-color: var(--bg-surface) !important;
-  color: var(--text-pri) !important;
-  font-family: &#x27;IBM Plex Mono&#x27;, monospace !important;
-  font-size: 0.82rem !important;
-  border-collapse: collapse !important;
-}
-
-th {
-  background-color: var(--bg-alt) !important;
-  color: var(--accent) !important;
-  font-weight: 500 !important;
-  text-transform: uppercase !important;
-  letter-spacing: 0.06em !important;
-  padding: 6px 10px !important;
-  border-bottom: 1px solid var(--border-strong) !important;
-}
-
-td {
-  padding: 4px 10px !important;
-  border-bottom: 1px solid var(--border-soft) !important;
-}
-
-tr:nth-child(even) td {
-  background-color: var(--bg-alt) !important;
-}
-
-tr:hover td {
-  background-color: rgba(232, 97, 10, 0.06) !important;
-}
-
-.gr-dropdown, .gr-select {
-  background-color: var(--bg-alt) !important;
-  border: 1px solid var(--border-strong) !important;
-  color: var(--text-pri) !important;
-  border-radius: var(--radius) !important;
-}
-
-.prose, .gr-markdown {
-  color: var(--text-pri) !important;
-  font-family: &#x27;IBM Plex Mono&#x27;, monospace !important;
-  line-height: 1.65 !important;
-}
-
-.prose strong, .gr-markdown strong {
-  color: var(--accent) !important;
-}
-
-.prose code, .gr-markdown code {
-  background-color: var(--bg-alt) !important;
-  color: var(--text-pri) !important;
-  padding: 0.1rem 0.3rem !important;
-  border-radius: 4px !important;
-  border: 1px solid var(--border-soft) !important;
-}
-
-label {
-  color: var(--text-mut) !important;
-  font-family: &#x27;IBM Plex Mono&#x27;, monospace !important;
-  font-size: 0.78rem !important;
-  letter-spacing: 0.04em !important;
-}
-&quot;&quot;&quot;
-
-</gradio-file>
-    </gradio-lite>
-    <script type="module" src="https://cdn.jsdelivr.net/npm/@gradio/lite/dist/lite.js"></script>
+    <main class="page-shell">
+      <section class="hero card">
+        <p class="eyebrow">Public Space / Static / 2x2 only</p>
+        <h1>Game Theory Matrix Classifier</h1>
+        <p class="hero-copy">
+          Lightweight public demo. Enter any 2x2 payoff matrix, find pure-strategy Nash equilibria,
+          compute mixed equilibrium when needed, classify classic game type.
+        </p>
+      </section>
+
+      <section class="layout">
+        <aside class="card controls">
+          <div class="section-head">
+            <p class="eyebrow">Inputs</p>
+            <h2>Matrix Builder</h2>
+          </div>
+
+          <label class="control-label" for="preset">Load preset</label>
+          <select id="preset" class="control-input"></select>
+
+          <div class="grid-head">
+            <span>Top row</span>
+            <span>Bottom row</span>
+          </div>
+
+          <div class="input-grid">
+            <label class="payoff-card">
+              <span class="payoff-label">(0,0)</span>
+              <div class="payoff-pair">
+                <input id="r0c0_p1" class="control-input" type="number" step="1" value="3">
+                <input id="r0c0_p2" class="control-input" type="number" step="1" value="3">
+              </div>
+            </label>
+
+            <label class="payoff-card">
+              <span class="payoff-label">(0,1)</span>
+              <div class="payoff-pair">
+                <input id="r0c1_p1" class="control-input" type="number" step="1" value="0">
+                <input id="r0c1_p2" class="control-input" type="number" step="1" value="5">
+              </div>
+            </label>
+
+            <label class="payoff-card">
+              <span class="payoff-label">(1,0)</span>
+              <div class="payoff-pair">
+                <input id="r1c0_p1" class="control-input" type="number" step="1" value="5">
+                <input id="r1c0_p2" class="control-input" type="number" step="1" value="0">
+              </div>
+            </label>
+
+            <label class="payoff-card">
+              <span class="payoff-label">(1,1)</span>
+              <div class="payoff-pair">
+                <input id="r1c1_p1" class="control-input" type="number" step="1" value="1">
+                <input id="r1c1_p2" class="control-input" type="number" step="1" value="1">
+              </div>
+            </label>
+          </div>
+
+          <div class="button-row">
+            <button id="analyze" class="primary-button" type="button">Analyze Matrix</button>
+            <button id="reset" class="ghost-button" type="button">Reset</button>
+          </div>
+
+          <div class="mini-note">
+            Presets include Prisoner's Dilemma, Battle of the Sexes, Stag Hunt, Chicken, Coordination, Matching Pennies.
+          </div>
+        </aside>
+
+        <section class="results">
+          <div class="card">
+            <div class="section-head">
+              <p class="eyebrow">Output 01</p>
+              <h2>Equilibrium Explorer</h2>
+            </div>
+
+            <div class="matrix-wrap">
+              <table class="matrix-table">
+                <thead>
+                  <tr>
+                    <th>Col 0</th>
+                    <th>Col 1</th>
+                  </tr>
+                </thead>
+                <tbody id="matrix-body"></tbody>
+              </table>
+            </div>
+
+            <div id="summary" class="summary-card"></div>
+          </div>
+
+          <div class="card">
+            <div class="section-head">
+              <p class="eyebrow">Output 02</p>
+              <h2>Classification</h2>
+            </div>
+
+            <div id="game-type-badge" class="game-type-badge"></div>
+            <p id="game-type-description" class="game-type-description"></p>
+
+            <div class="table-wrap">
+              <table class="properties-table">
+                <thead>
+                  <tr>
+                    <th>Property</th>
+                    <th>Value</th>
+                    <th>Note</th>
+                  </tr>
+                </thead>
+                <tbody id="properties-body"></tbody>
+              </table>
+            </div>
+          </div>
+        </section>
+      </section>
+    </main>
+
+    <script type="module" src="./app.mjs"></script>
   </body>
 </html>

style.css

@@ -1,28 +0,0 @@
-body {
-	padding: 2rem;
-	font-family: -apple-system, BlinkMacSystemFont, "Arial", sans-serif;
-}
-
-h1 {
-	font-size: 16px;
-	margin-top: 0;
-}
-
-p {
-	color: rgb(107, 114, 128);
-	font-size: 15px;
-	margin-bottom: 10px;
-	margin-top: 5px;
-}
-
-.card {
-	max-width: 620px;
-	margin: 0 auto;
-	padding: 16px;
-	border: 1px solid lightgray;
-	border-radius: 16px;
-}
-
-.card p:last-child {
-	margin-bottom: 0;
-}

styles.css

@@ -0,0 +1,340 @@
+:root {
+  --bg-page: #0f0f0f;
+  --bg-surface: #1a1410;
+  --bg-alt: #15110d;
+  --border-strong: #3d2418;
+  --border-soft: #2a2520;
+  --accent: #e8610a;
+  --accent-dim: #8c3a06;
+  --text-pri: #f0ede8;
+  --text-mut: #9a9288;
+  --text-dim: #62584f;
+  --good: #4caf82;
+  --shadow: 0 24px 80px rgba(0, 0, 0, 0.32);
+}
+
+* {
+  box-sizing: border-box;
+}
+
+html,
+body {
+  margin: 0;
+  min-height: 100%;
+  background:
+    radial-gradient(circle at top right, rgba(232, 97, 10, 0.16), transparent 26rem),
+    radial-gradient(circle at bottom left, rgba(58, 155, 213, 0.08), transparent 24rem),
+    linear-gradient(180deg, #0f0f0f 0%, #15100c 100%);
+  color: var(--text-pri);
+}
+
+body {
+  font-family: "IBM Plex Mono", monospace;
+}
+
+button,
+input,
+select {
+  font: inherit;
+}
+
+.page-shell {
+  width: min(1200px, calc(100% - 2rem));
+  margin: 0 auto;
+  padding: 1rem 0 2rem;
+}
+
+.layout {
+  display: grid;
+  gap: 1rem;
+  grid-template-columns: minmax(320px, 360px) minmax(0, 1fr);
+}
+
+.results {
+  display: grid;
+  gap: 1rem;
+}
+
+.card {
+  background: linear-gradient(180deg, rgba(26, 20, 16, 0.98), rgba(21, 17, 13, 0.98));
+  border: 1px solid var(--border-strong);
+  border-radius: 18px;
+  box-shadow: var(--shadow);
+  padding: 1.15rem;
+}
+
+.hero {
+  margin-bottom: 1rem;
+  padding: 1.4rem 1.2rem 1.3rem;
+}
+
+.hero h1,
+.section-head h2 {
+  font-family: "Space Grotesk", sans-serif;
+  font-weight: 700;
+  letter-spacing: -0.03em;
+  margin: 0;
+}
+
+.hero h1 {
+  font-size: clamp(1.8rem, 4vw, 3rem);
+  text-transform: uppercase;
+}
+
+.hero-copy {
+  color: var(--text-mut);
+  line-height: 1.7;
+  max-width: 58rem;
+  margin: 0.9rem 0 0;
+}
+
+.eyebrow {
+  margin: 0 0 0.55rem;
+  color: var(--accent);
+  font-size: 0.74rem;
+  letter-spacing: 0.14em;
+  text-transform: uppercase;
+}
+
+.section-head {
+  margin-bottom: 1rem;
+}
+
+.controls {
+  height: fit-content;
+}
+
+.control-label,
+.grid-head,
+.payoff-label,
+.mini-note {
+  color: var(--text-mut);
+  font-size: 0.78rem;
+}
+
+.control-input {
+  width: 100%;
+  background: var(--bg-alt);
+  color: var(--text-pri);
+  border: 1px solid var(--border-strong);
+  border-radius: 12px;
+  padding: 0.82rem 0.9rem;
+}
+
+.control-input:focus {
+  outline: none;
+  border-color: var(--accent);
+  box-shadow: 0 0 0 3px rgba(232, 97, 10, 0.14);
+}
+
+.grid-head {
+  display: flex;
+  justify-content: space-between;
+  text-transform: uppercase;
+  letter-spacing: 0.1em;
+  margin: 1rem 0 0.7rem;
+}
+
+.input-grid {
+  display: grid;
+  gap: 0.75rem;
+  grid-template-columns: repeat(2, minmax(0, 1fr));
+}
+
+.payoff-card {
+  display: grid;
+  gap: 0.55rem;
+  padding: 0.9rem;
+  background: rgba(255, 255, 255, 0.015);
+  border: 1px solid var(--border-soft);
+  border-radius: 14px;
+}
+
+.payoff-pair {
+  display: grid;
+  gap: 0.5rem;
+  grid-template-columns: repeat(2, minmax(0, 1fr));
+}
+
+.button-row {
+  display: flex;
+  gap: 0.7rem;
+  margin-top: 1rem;
+}
+
+.primary-button,
+.ghost-button {
+  border-radius: 12px;
+  padding: 0.9rem 1rem;
+  cursor: pointer;
+}
+
+.primary-button {
+  flex: 1 1 auto;
+  background: var(--accent);
+  color: white;
+  border: none;
+}
+
+.primary-button:hover {
+  background: var(--accent-dim);
+}
+
+.ghost-button {
+  background: transparent;
+  color: var(--text-mut);
+  border: 1px solid var(--border-strong);
+}
+
+.ghost-button:hover {
+  border-color: var(--accent);
+  color: var(--accent);
+}
+
+.mini-note {
+  margin-top: 0.85rem;
+  line-height: 1.6;
+}
+
+.matrix-wrap {
+  overflow-x: auto;
+}
+
+.matrix-table,
+.properties-table {
+  width: 100%;
+  border-collapse: collapse;
+}
+
+.matrix-table th,
+.properties-table th {
+  color: var(--accent);
+  background: rgba(255, 255, 255, 0.015);
+  border-bottom: 1px solid var(--border-strong);
+  padding: 0.85rem;
+  text-align: left;
+  text-transform: uppercase;
+  letter-spacing: 0.08em;
+  font-size: 0.72rem;
+}
+
+.matrix-cell,
+.properties-table td {
+  border-bottom: 1px solid var(--border-soft);
+  padding: 0.9rem 0.85rem;
+  vertical-align: top;
+}
+
+.matrix-cell {
+  width: 50%;
+  background: rgba(255, 255, 255, 0.015);
+}
+
+.matrix-cell.is-ne {
+  background: rgba(232, 97, 10, 0.1);
+  box-shadow: inset 0 0 0 1px rgba(232, 97, 10, 0.38);
+}
+
+.cell-coord,
+.cell-tag {
+  color: var(--text-dim);
+  font-size: 0.72rem;
+  text-transform: uppercase;
+  letter-spacing: 0.08em;
+}
+
+.cell-payoff {
+  font-family: "Space Grotesk", sans-serif;
+  font-size: 1.35rem;
+  margin: 0.3rem 0;
+}
+
+.cell-tag {
+  color: var(--accent);
+  min-height: 1rem;
+}
+
+.summary-card {
+  display: grid;
+  gap: 0.45rem;
+  margin-top: 1rem;
+  padding: 1rem;
+  border: 1px solid var(--border-strong);
+  border-radius: 14px;
+  background: rgba(255, 255, 255, 0.015);
+}
+
+.summary-line {
+  color: var(--text-mut);
+  line-height: 1.6;
+}
+
+.summary-line strong {
+  color: var(--text-pri);
+}
+
+.game-type-badge {
+  display: inline-flex;
+  align-items: center;
+  width: fit-content;
+  border: 1px solid currentColor;
+  border-radius: 999px;
+  padding: 0.5rem 0.85rem;
+  font-family: "Space Grotesk", sans-serif;
+  font-size: 1.4rem;
+  font-weight: 700;
+  letter-spacing: -0.02em;
+}
+
+.game-type-description {
+  color: var(--text-mut);
+  line-height: 1.75;
+  margin: 1rem 0 1.2rem;
+}
+
+.table-wrap {
+  overflow-x: auto;
+}
+
+.properties-table td:nth-child(2) {
+  color: var(--text-pri);
+  white-space: nowrap;
+}
+
+.properties-table td:nth-child(3) {
+  color: var(--text-dim);
+}
+
+.bool-yes {
+  color: var(--good);
+  font-weight: 700;
+}
+
+.bool-no {
+  color: var(--text-dim);
+  font-weight: 700;
+}
+
+@media (max-width: 900px) {
+  .layout {
+    grid-template-columns: 1fr;
+  }
+
+  .page-shell {
+    width: min(100% - 1rem, 1200px);
+  }
+}
+
+@media (max-width: 560px) {
+  .input-grid {
+    grid-template-columns: 1fr;
+  }
+
+  .button-row {
+    flex-direction: column;
+  }
+
+  .cell-payoff {
+    font-size: 1.1rem;
+  }
+}