From 70c7eff6e58a187103622752d392d46fb9f30fbb Mon Sep 17 00:00:00 2001 From: Amelie Kleber Date: Thu, 20 Aug 2026 10:31:52 +0200 Subject: [PATCH 1/3] sagemath tutorials --- doc/pygambit.rst | 2 + .../sagemath_extensive_form.ipynb | 1193 +++++++++++++ .../sagemath_normal_form.ipynb | 1537 +++++++++++++++++ pyproject.toml | 6 + tests/test_tutorials.py | 51 + 5 files changed, 2789 insertions(+) create mode 100644 doc/tutorials/interoperability_tutorials/sagemath_extensive_form.ipynb create mode 100644 doc/tutorials/interoperability_tutorials/sagemath_normal_form.ipynb diff --git a/doc/pygambit.rst b/doc/pygambit.rst index ce251cb5b..dba4d6a83 100644 --- a/doc/pygambit.rst +++ b/doc/pygambit.rst @@ -57,6 +57,8 @@ These tutorials assume you have read the new user tutorials and are familiar wit tutorials/interoperability_tutorials/openspiel tutorials/interoperability_tutorials/gamut + tutorials/interoperability_tutorials/sagemath_normal_form + tutorials/interoperability_tutorials/sagemath_extensive_form API documentation ---------------- diff --git a/doc/tutorials/interoperability_tutorials/sagemath_extensive_form.ipynb b/doc/tutorials/interoperability_tutorials/sagemath_extensive_form.ipynb new file mode 100644 index 000000000..6ed65ef8d --- /dev/null +++ b/doc/tutorials/interoperability_tutorials/sagemath_extensive_form.ipynb @@ -0,0 +1,1193 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "fd12d347", + "metadata": {}, + "source": "# Using Gambit with SageMath: extensive form games\n\nA strategic form game is a table of payoffs. An **extensive form game** is a tree: players move in sequence, chance may intervene, and a player may be unable to tell apart the situations they find themselves in.\n\nSageMath's `ExtensiveFormGame` is a thin layer over Gambit's tree games. The tree itself, the information sets, and the equilibrium solvers are all Gambit's; what Sage adds is its own notation, exact rational arithmetic, plotting, and the rest of a computer algebra system.\n\nThis tutorial builds a few trees, walks through the interface, and ends with a puzzle that Gambit's solvers deliberately refuse to answer — and that Sage can settle exactly.\n\nThe companion tutorial [Using Gambit with SageMath: strategic form games](sagemath_normal_form.ipynb) covers `NormalFormGame` and the strategic form interface.\n\n> **Requirements.** As for the companion tutorial: a SageMath build containing [sagemath/sage#42367](https://github.com/sagemath/sage/pull/42367), the optional `pygambit` package, and the **SageMath kernel**.\n> The `gtdraw` section additionally needs the optional `gtdraw` package and a LaTeX installation." + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "1024561a", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-18T22:21:58.846162Z", + "iopub.status.busy": "2026-08-18T22:21:58.845877Z", + "iopub.status.idle": "2026-08-18T22:22:00.295244Z", + "shell.execute_reply": "2026-08-18T22:22:00.294822Z" + } + }, + "outputs": [], + "source": [ + "from fractions import Fraction\n", + "\n", + "import pygambit as gbt" + ] + }, + { + "cell_type": "markdown", + "id": "09f9a136", + "metadata": {}, + "source": [ + "## Building a tree\n", + "\n", + "We build the Battle of the Sexes as a sequential game: Amy chooses first, Bob sees what she chose and responds.\n", + "\n", + "Two things are worth knowing before we start. Nodes carry **no labels** — following Gambit, a node is identified by the path of action labels leading to it, so `root.children['game']` is the node reached when Amy plays `game`. And an outcome is attached with `set_outcome`, which takes a label and the list of payoffs." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "ae2f549a", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-18T22:22:00.296450Z", + "iopub.status.busy": "2026-08-18T22:22:00.296335Z", + "iopub.status.idle": "2026-08-18T22:22:00.304715Z", + "shell.execute_reply": "2026-08-18T22:22:00.304304Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "An extensive form game with 2 players" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "battle = ExtensiveFormGame(players=[\"Amy\", \"Bob\"])\n", + "battle.append_move(battle.root, \"Amy\", [\"game\", \"movie\"])\n", + "\n", + "for choice in [\"game\", \"movie\"]:\n", + " battle.append_move(battle.root.children[choice], \"Bob\", [\"game\", \"movie\"])\n", + "\n", + "payoffs = {(\"game\", \"game\"): [3, 2], (\"game\", \"movie\"): [1, 1],\n", + " (\"movie\", \"game\"): [0, 0], (\"movie\", \"movie\"): [2, 3]}\n", + "\n", + "for (amy, bob), payoff in payoffs.items():\n", + " battle.set_outcome(battle.root.children[amy].children[bob],\n", + " f\"{amy},{bob}\", payoff)\n", + "\n", + "battle" + ] + }, + { + "cell_type": "markdown", + "id": "15e1547c", + "metadata": {}, + "source": [ + "Because Bob observes Amy's choice, he is at a different decision point in each branch. That gives three information sets — one for Amy and one for each of Bob's two nodes — each containing a single node." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "933a455b", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-18T22:22:00.305660Z", + "iopub.status.busy": "2026-08-18T22:22:00.305567Z", + "iopub.status.idle": "2026-08-18T22:22:00.307923Z", + "shell.execute_reply": "2026-08-18T22:22:00.307603Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "(3, [1, 1, 1])" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "len(battle.infosets), sorted(len(list(s.members)) for s in battle.infosets)" + ] + }, + { + "cell_type": "markdown", + "id": "68fb2823", + "metadata": {}, + "source": [ + "## Drawing the tree\n", + "\n", + "`plot` draws the tree. The default backend uses Sage's own graphics, so it works anywhere Sage does." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "469abff9", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-18T22:22:00.308784Z", + "iopub.status.busy": "2026-08-18T22:22:00.308710Z", + "iopub.status.idle": "2026-08-18T22:22:00.591180Z", + "shell.execute_reply": "2026-08-18T22:22:00.590770Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "Graphics object consisting of 20 graphics primitives" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "battle.plot(backend=\"sage\")" + ] + }, + { + "cell_type": "markdown", + "id": "28ec7be8", + "metadata": {}, + "source": [ + "The `'gtdraw'` backend instead produces a TikZ picture, which is what you want for a paper: it is vector output with real LaTeX typesetting. It returns a picture object that can be rendered to PDF, SVG or PNG, or whose LaTeX source you can paste into a document." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "22a8dabc", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-18T22:22:00.592358Z", + "iopub.status.busy": "2026-08-18T22:22:00.592235Z", + "iopub.status.idle": "2026-08-18T22:22:00.600318Z", + "shell.execute_reply": "2026-08-18T22:22:00.599927Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "% TikZ code with built-in styling for game trees\n", + "% TikZ libraries required for game trees\n", + "\\usetikzlibrary{shapes}\n", + "\\usetikzlibrary{arrows.meta}\n", + "\n", + "% Style settings for game tree formatting\n" + ] + } + ], + "source": [ + "picture = battle.plot(backend=\"gtdraw\")\n", + "print(\"\\n\".join(picture.content().splitlines()[:6]))" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "c29ffa88", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-18T22:22:00.601237Z", + "iopub.status.busy": "2026-08-18T22:22:00.601155Z", + "iopub.status.idle": "2026-08-18T22:22:01.665252Z", + "shell.execute_reply": "2026-08-18T22:22:01.664825Z" + } + }, + "outputs": [ + { + "data": { + "image/svg+xml": [ + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from IPython.display import SVG\n", + "\n", + "SVG(filename=picture.svg(view=False))" + ] + }, + { + "cell_type": "markdown", + "id": "2df55a18", + "metadata": {}, + "source": [ + "## Information sets\n", + "\n", + "Now suppose Amy and Bob choose *simultaneously*. The tree is the same shape, but Bob no longer knows which branch he is in: his two nodes have to be bundled into a single information set.\n", + "\n", + "`append_infoset` does that. Instead of giving Bob a fresh move at the second node, we say that the node belongs to the same information set as an existing one." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "1dde74fc", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-18T22:22:01.666620Z", + "iopub.status.busy": "2026-08-18T22:22:01.666513Z", + "iopub.status.idle": "2026-08-18T22:22:01.669767Z", + "shell.execute_reply": "2026-08-18T22:22:01.669322Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "(2, [1, 2])" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "simultaneous = ExtensiveFormGame(players=[\"Amy\", \"Bob\"])\n", + "simultaneous.append_move(simultaneous.root, \"Amy\", [\"game\", \"movie\"])\n", + "simultaneous.append_move(simultaneous.root.children[\"game\"], \"Bob\",\n", + " [\"game\", \"movie\"])\n", + "simultaneous.append_infoset(simultaneous.root.children[\"movie\"],\n", + " simultaneous.root.children[\"game\"])\n", + "\n", + "for (amy, bob), payoff in payoffs.items():\n", + " simultaneous.set_outcome(simultaneous.root.children[amy].children[bob],\n", + " f\"{amy},{bob}\", payoff)\n", + "\n", + "len(simultaneous.infosets), sorted(len(list(s.members))\n", + " for s in simultaneous.infosets)" + ] + }, + { + "cell_type": "markdown", + "id": "7ba40bdc", + "metadata": {}, + "source": [ + "Two information sets now, one of which contains two nodes. Sage can also confirm that the game has perfect recall, meaning no player ever forgets something they previously knew — an assumption every one of Gambit's solvers relies on." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "6e0e6e2d", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-18T22:22:01.670732Z", + "iopub.status.busy": "2026-08-18T22:22:01.670629Z", + "iopub.status.idle": "2026-08-18T22:22:01.672787Z", + "shell.execute_reply": "2026-08-18T22:22:01.672417Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "True" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "simultaneous.is_perfect_recall" + ] + }, + { + "cell_type": "markdown", + "id": "abc8a31e", + "metadata": {}, + "source": [ + "That single change to the information structure changes the answer.\n", + "`obtain_nash` sends the game to a Gambit solver and hands back equilibria as behaviour profiles; we read off what each is worth to each player, exactly, with `QQ`." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "97932afe", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-18T22:22:01.673624Z", + "iopub.status.busy": "2026-08-18T22:22:01.673545Z", + "iopub.status.idle": "2026-08-18T22:22:01.677339Z", + "shell.execute_reply": "2026-08-18T22:22:01.677062Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "sequential [[3, 2], [3, 2], [2, 3]]\n", + "simultaneous [[3, 2], [2, 3]]\n" + ] + } + ], + "source": [ + "def payoff_table(game, equilibria):\n", + " return [[QQ(eq.payoff(player)) for player in game.players]\n", + " for eq in equilibria]\n", + "\n", + "\n", + "print(\"sequential \", payoff_table(battle,\n", + " battle.obtain_nash(algorithm=\"enumpure\")))\n", + "print(\"simultaneous\", payoff_table(simultaneous,\n", + " simultaneous.obtain_nash(algorithm=\"enumpure\")))" + ] + }, + { + "cell_type": "markdown", + "id": "839852c9", + "metadata": {}, + "source": [ + "When Bob moves second he can condition on Amy's choice, and there are three pure equilibria (two of which end at the same outcome). When the players move simultaneously, only two survive." + ] + }, + { + "cell_type": "markdown", + "id": "dc5db809", + "metadata": {}, + "source": [ + "## Chance moves\n", + "\n", + "Real games often start with a deal, a roll, or some other move by nature. `append_chance_move` adds one, with exact rational probabilities.\n", + "\n", + "Here is a miniature poker game. Nature deals Alice a high or low card. Alice sees it and either bets or checks. Bob does *not* see the card — his two nodes go into one information set — and either calls or folds." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "035299df", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-18T22:22:01.678250Z", + "iopub.status.busy": "2026-08-18T22:22:01.678175Z", + "iopub.status.idle": "2026-08-18T22:22:01.712644Z", + "shell.execute_reply": "2026-08-18T22:22:01.712252Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "Graphics object consisting of 32 graphics primitives" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "poker = ExtensiveFormGame(players=[\"Alice\", \"Bob\"])\n", + "poker.append_chance_move(poker.root, [\"High\", \"Low\"], [1/2, 1/2])\n", + "\n", + "for card in [\"High\", \"Low\"]:\n", + " poker.append_move(poker.root.children[card], \"Alice\", [\"bet\", \"check\"])\n", + "\n", + "poker.append_move(poker.root.children[\"High\"].children[\"bet\"], \"Bob\",\n", + " [\"call\", \"fold\"])\n", + "poker.append_infoset(poker.root.children[\"Low\"].children[\"bet\"],\n", + " poker.root.children[\"High\"].children[\"bet\"])\n", + "\n", + "showdown = {(\"High\", \"bet\", \"call\"): [2, -2], (\"High\", \"bet\", \"fold\"): [1, -1],\n", + " (\"Low\", \"bet\", \"call\"): [-2, 2], (\"Low\", \"bet\", \"fold\"): [1, -1]}\n", + "for (card, action, response), payoff in showdown.items():\n", + " poker.set_outcome(\n", + " poker.root.children[card].children[action].children[response],\n", + " f\"{card},{action},{response}\", payoff)\n", + "\n", + "poker.set_outcome(poker.root.children[\"High\"].children[\"check\"],\n", + " \"High,check\", [1, -1])\n", + "poker.set_outcome(poker.root.children[\"Low\"].children[\"check\"],\n", + " \"Low,check\", [-1, 1])\n", + "\n", + "poker.plot(backend=\"sage\")" + ] + }, + { + "cell_type": "markdown", + "id": "56e531a8", + "metadata": {}, + "source": [ + "Alice knows her card and Bob does not, so this is a game of incomplete information — and its equilibrium involves bluffing. Gambit computes it, and because we ask for exact output, Sage reports the answer in rationals rather than decimals." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "53bf7311", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-18T22:22:01.713604Z", + "iopub.status.busy": "2026-08-18T22:22:01.713520Z", + "iopub.status.idle": "2026-08-18T22:22:01.717115Z", + "shell.execute_reply": "2026-08-18T22:22:01.716807Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "{'Alice bets holding High': 1,\n", + " 'Alice bets holding Low (a bluff)': 1/3,\n", + " 'Bob calls': 2/3}" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "equilibrium = poker.obtain_nash()[0]\n", + "game = poker._gambit_()\n", + "\n", + "with_high, with_low = game.players[\"Alice\"].infosets\n", + "bob_infoset, = game.players[\"Bob\"].infosets\n", + "\n", + "{\"Alice bets holding High\": QQ(equilibrium[with_high.actions[\"bet\"]]),\n", + " \"Alice bets holding Low (a bluff)\": QQ(equilibrium[with_low.actions[\"bet\"]]),\n", + " \"Bob calls\": QQ(equilibrium[bob_infoset.actions[\"call\"]])}" + ] + }, + { + "cell_type": "markdown", + "id": "2b75e1c9", + "metadata": {}, + "source": [ + "Alice always bets with a high card, bluffs with a low card exactly one third of the time, and Bob calls two thirds of the time. The game is worth `1/3` to Alice:" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "cfe68ddf", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-18T22:22:01.718071Z", + "iopub.status.busy": "2026-08-18T22:22:01.717992Z", + "iopub.status.idle": "2026-08-18T22:22:01.720344Z", + "shell.execute_reply": "2026-08-18T22:22:01.719939Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "1/3" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "QQ(equilibrium.payoff(game.players[\"Alice\"]))" + ] + }, + { + "cell_type": "markdown", + "id": "215c3289", + "metadata": {}, + "source": [ + "## Moving games between Sage and Gambit\n", + "\n", + "An `ExtensiveFormGame` can also wrap a tree game you already built with PyGambit. The wrapper does not copy anything — `_gambit_` hands back the very same object, so the two views stay in sync." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "8528d0b7", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-18T22:22:01.721216Z", + "iopub.status.busy": "2026-08-18T22:22:01.721132Z", + "iopub.status.idle": "2026-08-18T22:22:01.723876Z", + "shell.execute_reply": "2026-08-18T22:22:01.723569Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "(An extensive form game with 2 players, True)" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "tree = gbt.Game.new_tree(players=[\"Alice\", \"Bob\"], title=\"tiny\")\n", + "tree.append_move(tree.root, tree.players[\"Alice\"], [\"L\", \"R\"])\n", + "for leaf, label, payoff in zip(tree.root.children, [\"L\", \"R\"],\n", + " [[2, 5], [3, 1]], strict=True):\n", + " tree.set_outcome(leaf, tree.add_outcome(label, payoff))\n", + "\n", + "wrapped = ExtensiveFormGame(tree)\n", + "wrapped, wrapped._gambit_() is tree" + ] + }, + { + "cell_type": "markdown", + "id": "45db887f", + "metadata": {}, + "source": [ + "Games can be written to and read from Gambit's `.efg` format, so a tree built in Sage can be opened in the Gambit GUI and vice versa." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "a915228c", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-18T22:22:01.724882Z", + "iopub.status.busy": "2026-08-18T22:22:01.724812Z", + "iopub.status.idle": "2026-08-18T22:22:01.727217Z", + "shell.execute_reply": "2026-08-18T22:22:01.726892Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "EFG 2 R \"Untitled extensive game\" { \"Alice\" \"Bob\" }\n", + "\"\"\n", + "\n", + "c \"\" 1 \"\" { \"High\" 1/2 \"Low\" 1/2 } 0\n", + "p \"\" 1 1 \"\" { \"bet\" \"check\" } 0\n", + "p \"\" 2 1 \"\" { \"call\" \"fold\" } 0\n", + "t \"\" 1 \"High,bet,call\" { 2, -2 }\n", + "t \"\" 2 \"High,bet,fold\" { 1, -1\n" + ] + } + ], + "source": [ + "path = tmp_filename(ext=\".efg\")\n", + "poker.save_efg(path)\n", + "\n", + "with open(path) as handle:\n", + " print(handle.read()[:220])" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "3a1e9237", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-18T22:22:01.728051Z", + "iopub.status.busy": "2026-08-18T22:22:01.727979Z", + "iopub.status.idle": "2026-08-18T22:22:01.730216Z", + "shell.execute_reply": "2026-08-18T22:22:01.729921Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "(An extensive form game with 2 players, 3)" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "reloaded = ExtensiveFormGame()\n", + "reloaded.load_efg(path)\n", + "reloaded, len(reloaded.infosets)" + ] + }, + { + "cell_type": "markdown", + "id": "8eedd88c", + "metadata": {}, + "source": [ + "## The game catalog\n", + "\n", + "As in the strategic form case, Gambit's catalog of games from the literature is available directly.\n", + "Selten's horse is the classic example of a Nash equilibrium that is not sequentially rational." + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "c1c7dce7", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-18T22:22:01.731128Z", + "iopub.status.busy": "2026-08-18T22:22:01.731056Z", + "iopub.status.idle": "2026-08-18T22:22:01.733792Z", + "shell.execute_reply": "2026-08-18T22:22:01.733487Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "(An extensive form game with 3 players, [[1, 1, 1], [3, 2, 2]])" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "horse = ExtensiveFormGame()\n", + "horse.load_from_gambit_catalog(\"journals/ijgt/selten1975/fig1\", info=False)\n", + "\n", + "horse, payoff_table(horse, horse.obtain_nash(algorithm=\"enumpure\"))" + ] + }, + { + "cell_type": "markdown", + "id": "a3fc7265", + "metadata": {}, + "source": "Both are Nash equilibria, but only one of them survives if you insist that every player behave optimally at every information set they might reach.\n\nThe usual tool for ruling out the other one is subgame perfection, and here it is no help at all: only the root begins a subgame, so the game has no *proper* subgames to refine away anything. That is exactly why Selten introduced this example." + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "2e2693cc", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-18T22:22:01.734656Z", + "iopub.status.busy": "2026-08-18T22:22:01.734580Z", + "iopub.status.idle": "2026-08-18T22:22:01.736902Z", + "shell.execute_reply": "2026-08-18T22:22:01.736527Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "[True, False, False]" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "[node.is_subgame_root for node in [horse.root,\n", + " horse.root.children[\"L\"],\n", + " horse.root.children[\"R\"]]]" + ] + }, + { + "cell_type": "markdown", + "id": "cdcdca5d", + "metadata": {}, + "source": [ + "## Case study: the absent-minded driver\n", + "\n", + "Every solver in Gambit assumes **perfect recall**. When a game violates that assumption, Gambit will not compute equilibria for it — and it is right not to, because the standard theory does not apply.\n", + "\n", + "The best known such game is Piccione and Rubinstein's absent-minded driver. A driver must take the second of two identical exits. The two junctions look exactly the same, so they lie in one information set, and at each the driver either continues or exits. Since he cannot tell them apart, he cannot condition on which one he is at.\n", + "\n", + "Gilboa's version of the game is in the catalog." + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "bf14b609", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-18T22:22:01.737719Z", + "iopub.status.busy": "2026-08-18T22:22:01.737649Z", + "iopub.status.idle": "2026-08-18T22:22:01.739973Z", + "shell.execute_reply": "2026-08-18T22:22:01.739650Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "(An extensive form game with 1 player, False, 1)" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "driver = ExtensiveFormGame()\n", + "driver.load_from_gambit_catalog(\"journals/geb/gilboa1997/fig1\", info=False)\n", + "\n", + "driver, driver.is_perfect_recall, len(driver.infosets)" + ] + }, + { + "cell_type": "markdown", + "id": "b7dfd7d5", + "metadata": {}, + "source": [ + "One player, one information set, and no perfect recall — so `obtain_nash` is off the table.\n", + "\n", + "What we can still do is hand Gambit a *plan* and ask what it is worth. A plan here is a single number: the probability $p$ of continuing at a junction. Gambit evaluates it exactly." + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "02488d73", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-18T22:22:01.740816Z", + "iopub.status.busy": "2026-08-18T22:22:01.740742Z", + "iopub.status.idle": "2026-08-18T22:22:01.743729Z", + "shell.execute_reply": "2026-08-18T22:22:01.743397Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "[(0, 0), (1/4, 13/16), (1/2, 5/4), (3/4, 21/16), (1, 1)]" + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "game = driver._gambit_()\n", + "\n", + "\n", + "def value(p):\n", + " \"\"\"Expected payoff of continuing with probability ``p`` at each junction.\"\"\"\n", + " plan = game.mixed_behavior_profile(rational=True)\n", + " plan[game.actions[\"B\"]] = Fraction(str(p))\n", + " plan[game.actions[\"E\"]] = Fraction(str(1 - p))\n", + " return QQ(plan.payoff(game.players[\"Player 1\"]))\n", + "\n", + "\n", + "[(p, value(p)) for p in [0, 1/4, 1/2, 3/4, 1]]" + ] + }, + { + "cell_type": "markdown", + "id": "f997d2f4", + "metadata": {}, + "source": [ + "Gambit evaluates one plan at a time. Sage can recover the whole function.\n", + "\n", + "The value is a polynomial in $p$ of degree two — the driver passes at most two junctions — so five exact sample points are more than enough to reconstruct it by interpolation over `QQ`. No floating point, no curve fitting." + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "dc58a657", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-18T22:22:01.744588Z", + "iopub.status.busy": "2026-08-18T22:22:01.744516Z", + "iopub.status.idle": "2026-08-18T22:22:01.748349Z", + "shell.execute_reply": "2026-08-18T22:22:01.748106Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "-3*p^2 + 4*p" + ] + }, + "execution_count": 20, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "R = QQ[\"p\"]\n", + "value_polynomial = R.lagrange_polynomial([(p, value(p))\n", + " for p in [0, 1/4, 1/2, 3/4, 1]])\n", + "value_polynomial" + ] + }, + { + "cell_type": "markdown", + "id": "5f393739", + "metadata": {}, + "source": [ + "With the value function in hand, finding the best plan is calculus, which is exactly what Sage is for." + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "ef08e1d5", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-18T22:22:01.749317Z", + "iopub.status.busy": "2026-08-18T22:22:01.749245Z", + "iopub.status.idle": "2026-08-18T22:22:02.528075Z", + "shell.execute_reply": "2026-08-18T22:22:02.527687Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "[p == (2/3)]" + ] + }, + "execution_count": 21, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "p = var(\"p\")\n", + "expected_value = value_polynomial(p)\n", + "\n", + "critical_points = solve(diff(expected_value, p) == 0, p)\n", + "critical_points" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "bf6cd8ae", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-18T22:22:02.529200Z", + "iopub.status.busy": "2026-08-18T22:22:02.529104Z", + "iopub.status.idle": "2026-08-18T22:22:02.531358Z", + "shell.execute_reply": "2026-08-18T22:22:02.530986Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "(2/3, 4/3)" + ] + }, + "execution_count": 22, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "p_star = critical_points[0].rhs()\n", + "p_star, expected_value.subs(p=p_star)" + ] + }, + { + "cell_type": "markdown", + "id": "f1b81467", + "metadata": {}, + "source": [ + "So the driver's best plan is to continue with probability $2/3$, worth $4/3$ — both exact.\n", + "\n", + "The interesting part is the comparison with $p = 1/3$, the probability at which the driver, reasoning at a junction about what to do *now*, is indifferent between continuing and exiting. That plan is worth only $1$. Planning ahead and reasoning in the moment give genuinely different answers, which is the whole point of the example." + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "9738648b", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-18T22:22:02.532386Z", + "iopub.status.busy": "2026-08-18T22:22:02.532301Z", + "iopub.status.idle": "2026-08-18T22:22:02.534639Z", + "shell.execute_reply": "2026-08-18T22:22:02.534235Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "(1, 4/3)" + ] + }, + "execution_count": 23, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "value(1/3), value(p_star)" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "id": "e0da0793", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-18T22:22:02.535514Z", + "iopub.status.busy": "2026-08-18T22:22:02.535439Z", + "iopub.status.idle": "2026-08-18T22:22:02.610306Z", + "shell.execute_reply": "2026-08-18T22:22:02.609858Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "Graphics object consisting of 3 graphics primitives" + ] + }, + "execution_count": 24, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "plot(expected_value, (p, 0, 1), thickness=2, gridlines=True,\n", + " axes_labels=[\"probability $p$ of continuing\", \"expected payoff\"]) \\\n", + " + point((p_star, value(p_star)), size=60, color=\"red\") \\\n", + " + point((1/3, value(1/3)), size=60, color=\"green\")" + ] + }, + { + "cell_type": "markdown", + "id": "6ffa0b96", + "metadata": {}, + "source": [ + "The red point is the optimal plan, the green one the point of indifference at a junction.\n", + "\n", + "Gambit evaluated the plans; Sage found the function behind them and optimised it. Neither step works without the other.\n", + "\n", + "## Summary\n", + "\n", + "| Task | Call |\n", + "|---|---|\n", + "| New tree | `ExtensiveFormGame(players=[...])` |\n", + "| Wrap a PyGambit tree | `ExtensiveFormGame(game)` |\n", + "| Add a move | `game.append_move(node, player, actions)` |\n", + "| Add a move by chance | `game.append_chance_move(node, actions, probs)` |\n", + "| Bundle nodes into one information set | `game.append_infoset(node, like)` |\n", + "| Attach payoffs | `game.set_outcome(node, label, payoffs)` |\n", + "| Navigate | `game.root.children['action']` |\n", + "| Check the recall assumption | `game.is_perfect_recall` |\n", + "| Solve | `game.obtain_nash(algorithm='enumpure')` |\n", + "| Draw | `game.plot(backend='sage')`, `game.plot(backend='gtdraw')` |\n", + "| Read and write `.efg` | `game.load_efg(path)`, `game.save_efg(path)` |\n", + "| Catalog | `game.load_from_gambit_catalog()` |\n", + "\n", + "Further reading:\n", + "\n", + "- [SageMath game theory reference](https://doc.sagemath.org/html/en/reference/game_theory/index.html)\n", + "- [PyGambit API documentation](https://gambitproject.readthedocs.io/en/latest/pygambit.api.html)\n", + "- [Gambit's own extensive form tutorial](../02_extensive_form.ipynb)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "SageMath", + "language": "sage", + "name": "sagemath" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.13" + }, + "nbsphinx": { + "execute": "never" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/doc/tutorials/interoperability_tutorials/sagemath_normal_form.ipynb b/doc/tutorials/interoperability_tutorials/sagemath_normal_form.ipynb new file mode 100644 index 000000000..9fbbefa63 --- /dev/null +++ b/doc/tutorials/interoperability_tutorials/sagemath_normal_form.ipynb @@ -0,0 +1,1537 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "1c480c77", + "metadata": {}, + "source": [ + "# Using Gambit with SageMath: strategic form games\n", + "\n", + "[SageMath](https://www.sagemath.org/) is a general-purpose open-source mathematics system built on top of Python.\n", + "Its `sage.game_theory` module inclludes a `NormalFormGame` class, which integrates Gambit solvers.\n", + "\n", + "This tutorial shows how a game can be created and analyzed by the two libraries, walks through each part of the interface, and finishes with two case studies that use SageMath to do things Gambit cannot do on its own: solving a game whose payoffs are *symbols* rather than numbers, and building a game out of a combinatorial object.\n", + "\n", + "The clear benefit of using both libraries is their combined expertise:\n", + "\n", + "- **Gambit** knows how to compute equilibria. Its solvers are fast, numerous, and established.\n", + "- **SageMath** knows how to do mathematics *around* the game: exact rational and symbolic algebra, graphs and other combinatorial structures, plotting, and calculus.\n", + "\n", + "> **Requirements.** This tutorial uses the SageMath interface introduced in [sagemath/sage#42367](https://github.com/sagemath/sage/pull/42367), which at the time of writing has not yet been released.\n", + "> You will need a SageMath build containing that work, plus the optional `pygambit` package (`sage --pip install pygambit`).\n", + "> Run the notebook with the **SageMath kernel**, not a plain Python kernel: the examples below rely on Sage's preparser, which makes `1/3` an exact rational rather than a floating point number." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "d1134409", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-18T22:21:47.941506Z", + "iopub.status.busy": "2026-08-18T22:21:47.941209Z", + "iopub.status.idle": "2026-08-18T22:21:49.478843Z", + "shell.execute_reply": "2026-08-18T22:21:49.478420Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "SageMath 10.10.beta6 | pygambit 16.7.0\n" + ] + } + ], + "source": [ + "import itertools\n", + "\n", + "import numpy as np\n", + "from sage.version import version\n", + "\n", + "import pygambit as gbt\n", + "\n", + "print(\"SageMath\", version, \"| pygambit\", gbt.__version__)" + ] + }, + { + "cell_type": "markdown", + "id": "84b38ee5", + "metadata": {}, + "source": [ + "## From a Gambit game to a Sage game\n", + "\n", + "We start on the Gambit side, with the Prisoner's Dilemma built from a pair of payoff arrays." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "bb4c86e2", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-18T22:21:49.479965Z", + "iopub.status.busy": "2026-08-18T22:21:49.479851Z", + "iopub.status.idle": "2026-08-18T22:21:49.485213Z", + "shell.execute_reply": "2026-08-18T22:21:49.484905Z" + } + }, + "outputs": [ + { + "data": { + "text/html": [ + "

Prisoner's Dilemma

\n", + "
2
12
113,30,5
25,01,1
\n" + ], + "text/plain": [ + "Game(title='Prisoner's Dilemma')" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "pd_gambit = gbt.Game.from_arrays(\n", + " np.array([[3, 0], [5, 1]]),\n", + " np.array([[3, 5], [0, 1]]),\n", + " title=\"Prisoner's Dilemma\",\n", + ")\n", + "pd_gambit" + ] + }, + { + "cell_type": "markdown", + "id": "c96064c9", + "metadata": {}, + "source": [ + "Passing that `Game` straight to `NormalFormGame` converts it.\n", + "A Sage normal form game is a mapping from strategy profiles (tuples of integers) to lists of payoffs, so this is what we get back:" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "863f135f", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-18T22:21:49.486229Z", + "iopub.status.busy": "2026-08-18T22:21:49.486152Z", + "iopub.status.idle": "2026-08-18T22:21:49.502014Z", + "shell.execute_reply": "2026-08-18T22:21:49.501616Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "Normal Form Game with the following utilities: {(0, 0): [3, 3], (0, 1): [0, 5], (1, 0): [5, 0], (1, 1): [1, 1]}" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "pd = NormalFormGame(pd_gambit)\n", + "pd" + ] + }, + { + "cell_type": "markdown", + "id": "d69f3883", + "metadata": {}, + "source": [ + "Notice what happened to the numbers.\n", + "Gambit stores payoffs either as exact rationals or as decimals, and Sage keeps that distinction: the integer payoffs above came back as elements of `QQ`, the field of rational numbers, and *not* as floating point approximations." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "e4fb56bb", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-18T22:21:49.503043Z", + "iopub.status.busy": "2026-08-18T22:21:49.502945Z", + "iopub.status.idle": "2026-08-18T22:21:49.505457Z", + "shell.execute_reply": "2026-08-18T22:21:49.505103Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "Rational Field" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "parent(pd.utilities[(0, 0)][0])" + ] + }, + { + "cell_type": "markdown", + "id": "4693f7cf", + "metadata": {}, + "source": [ + "That matters for everything downstream. `payoff_matrices` hands us the two payoff matrices as genuine Sage matrices over `QQ`, which we can then do linear algebra on." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "6608cae6", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-18T22:21:49.506382Z", + "iopub.status.busy": "2026-08-18T22:21:49.506304Z", + "iopub.status.idle": "2026-08-18T22:21:49.511185Z", + "shell.execute_reply": "2026-08-18T22:21:49.510930Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "(\n", + "[3 0] [3 5] \n", + "[5 1], [0 1], Rational Field\n", + ")" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "A, B = pd.payoff_matrices()\n", + "A, B, A.base_ring()" + ] + }, + { + "cell_type": "markdown", + "id": "3bc37b15", + "metadata": {}, + "source": [ + "## From a Sage game to a Gambit game\n", + "\n", + "The other direction is the `_gambit_` method, which every Sage object that knows how to talk to Gambit provides.\n", + "It returns a `pygambit.Game`, so the whole Gambit API is available from there — including writing the game out in Gambit's own strategic form format." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "5e49d4cf", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-18T22:21:49.512292Z", + "iopub.status.busy": "2026-08-18T22:21:49.512184Z", + "iopub.status.idle": "2026-08-18T22:21:49.514162Z", + "shell.execute_reply": "2026-08-18T22:21:49.513785Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "NFG 1 R \"Untitled strategic game\" { \"1\" \"2\" }\n", + "\n", + "{ { \"1\" \"2\" }\n", + "{ \"1\" \"2\" }\n", + "}\n", + "\"\"\n", + "\n", + "{\n", + "{ \"\" 3.0, 3.0 }\n", + "{ \"\" 5.0, 0.0 }\n", + "{ \"\" 0.0, 5.0 }\n", + "{ \"\" 1.0, 1.0 }\n", + "}\n", + "1 2 3 4 \n", + "\n" + ] + } + ], + "source": [ + "print(pd._gambit_().to_nfg())" + ] + }, + { + "cell_type": "markdown", + "id": "0f683478", + "metadata": {}, + "source": [ + "Two options are worth knowing about:\n", + "\n", + "- `as_integer=True` truncates every payoff to an integer, which is useful when a solver benefits from exact integer arithmetic.\n", + "- `maximization=False` negates every payoff, so a game written down in terms of *costs* is handed to Gambit as a game to be maximised." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "fecfdf0f", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-18T22:21:49.515057Z", + "iopub.status.busy": "2026-08-18T22:21:49.514981Z", + "iopub.status.idle": "2026-08-18T22:21:49.517509Z", + "shell.execute_reply": "2026-08-18T22:21:49.517179Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "[3.0, 3, -3.0]" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "g_float = pd._gambit_()\n", + "g_int = pd._gambit_(as_integer=True)\n", + "g_min = pd._gambit_(maximization=False)\n", + "\n", + "[float(g_float[\"1\", \"1\"][g_float.players[\"1\"]]),\n", + " int(g_int[\"1\", \"1\"][g_int.players[\"1\"]]),\n", + " float(g_min[\"1\", \"1\"][g_min.players[\"1\"]])]" + ] + }, + { + "cell_type": "markdown", + "id": "42bda8b9", + "metadata": {}, + "source": [ + "## Saving and loading games\n", + "\n", + "Because the conversion goes through Gambit, Sage can read and write Gambit's `.nfg` files directly.\n", + "This is the simplest way to move a game between a Sage session and the Gambit GUI, or to keep a game under version control." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "537d16f8", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-18T22:21:49.518348Z", + "iopub.status.busy": "2026-08-18T22:21:49.518280Z", + "iopub.status.idle": "2026-08-18T22:21:49.521428Z", + "shell.execute_reply": "2026-08-18T22:21:49.521107Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "Normal Form Game with the following utilities: {(0, 0): [3.0, 3.0], (0, 1): [0.0, 5.0], (1, 0): [5.0, 0.0], (1, 1): [1.0, 1.0]}" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "path = tmp_filename(ext=\".nfg\")\n", + "pd.save_nfg(path)\n", + "\n", + "reloaded = NormalFormGame()\n", + "reloaded.load_nfg(path)\n", + "reloaded" + ] + }, + { + "cell_type": "markdown", + "id": "9cc777d6", + "metadata": {}, + "source": [ + "One caveat: a `.nfg` file records payoffs as decimals, so a round trip through disk turns exact rationals into floating point numbers.\n", + "If you care about exactness, keep the Sage object and convert on demand rather than saving and reloading." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "74dbb8a2", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-18T22:21:49.522346Z", + "iopub.status.busy": "2026-08-18T22:21:49.522272Z", + "iopub.status.idle": "2026-08-18T22:21:49.524298Z", + "shell.execute_reply": "2026-08-18T22:21:49.523997Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "parent(reloaded.utilities[(0, 0)][0])" + ] + }, + { + "cell_type": "markdown", + "id": "15f5764a", + "metadata": {}, + "source": [ + "## The Gambit game catalog\n", + "\n", + "Gambit ships a catalog of games from the research literature, and Sage can pull any of them in.\n", + "Called with no arguments, `load_from_gambit_catalog` returns a table of what is available." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "1f4c31df", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-18T22:21:49.525171Z", + "iopub.status.busy": "2026-08-18T22:21:49.525091Z", + "iopub.status.idle": "2026-08-18T22:21:49.539496Z", + "shell.execute_reply": "2026-08-18T22:21:49.539116Z" + } + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
GameTitle
0books/myerson1991/fig2_1A simple Poker game
1books/myerson1991/fig4_2Myerson (1991) Figure 4.2
2books/shohamleytonbrown2008/fig5_1Fig 5.1 from Shoham and Leyton-Brown (2008)
3books/shohamleytonbrown2008/fig5_10Fig 5.10 from Shoham and Leyton-Brown (2008)
4books/shohamleytonbrown2008/fig5_11Fig 5.11 from Shoham and Leyton-Brown (2008)
5books/shohamleytonbrown2008/fig5_12Fig 5.12 from Shoham and Leyton-Brown (2008)
6books/shohamleytonbrown2008/fig5_15Fig 5.15 from Shoham and Leyton-Brown (2008)
7books/shohamleytonbrown2008/fig5_2Fig 5.2 from Shoham and Leyton-Brown (2008)
8books/shohamleytonbrown2008/fig5_9Fig 5.9 from Shoham and Leyton-Brown (2008)
9books/shohamleytonbrown2008/fig6_2Fig 6.2 from Shoham and Leyton-Brown (2008)
10books/shohamleytonbrown2008/fig6_8Fig 6.8 from Shoham and Leyton-Brown (2008)
11books/vonstengel2022/fig10.1Figure 10.1 from von Stengel (2022)
12books/vonstengel2022/fig10.12Figure 10.12 from von Stengel (2022)
13books/vonstengel2022/fig10.5Figure 10.5 from von Stengel (2022)
14books/vonstengel2022/fig10.7Figure 10.7 from von Stengel (2022)
15books/watson2013/exercise29_6Princess Bride signaling game (from Watson)
16books/watson2013/fig29_1Job-market signaling game (version from Watson)
17conf/itcs/jakobsen2016/fig1aJakobsen, Sorensen, Conitzer (2016) Figure 1(a)
18conf/itcs/jakobsen2016/fig1bJakobsen, Sorensen, Conitzer (2016) Figure 1(b)
19conf/itcs/jakobsen2016/fig1cJakobsen, Sorensen, Conitzer (2016) Figure 1(c)
20conf/itcs/jakobsen2016/fig3Jakobsen, Sorensen, Conitzer (2016) Figure 3
21journals/geb/bagwell1995Bagwell (GEB 1995) commitment and (un)observab...
22journals/geb/gilboa1997/fig1Absent-Minded Driver (Gilboa 1997, GEB, Figure 2)
23journals/geb/gilboa1997/fig2Two-Selves Absent-Minded Driver (Gilboa 1997, ...
24journals/geb/wichardt2008Wichardt (2008): 2 players, imperfect recall
25journals/ijgt/nau2004/sec3Battle of the Sexes
26journals/ijgt/nau2004/sec4Three-player game with a unique Nash solution ...
27journals/ijgt/nau2004/sec5Game with a continuum of completely mixed-stra...
28journals/ijgt/nau2004/sec62x2x4 game with Nash equilibria in the relativ...
29journals/ijgt/selten1975/fig1Selten's horse (Selten IJGT 1975, Figure 1)
30journals/ijgt/selten1975/fig2Selten (IJGT 1975) Figure 2
31journals/ijgt/selten1975/fig3Selten (IJGT 1975) Figure 3
32journals/mor/vonstengelforges2008/fig1Figure 1 from von Stengel and Forges (2008)
33journals/mor/vonstengelforges2008/fig6Figure 6 from von Stengel and Forges (2008)
34journals/mor/vonstengelforges2008/fig9Figure 9 from von Stengel and Forges (2008)
35journals/other/reiley2008/fig1Stripped-down poker (Reiley et al 2008)
36journals/other/shapley1974/fig2Fig 2 from 'A Note on the Lemke-Howson Algorit...
37journals/other/shapley1974/fig3Fig 3 from 'A Note on the Lemke-Howson Algorit...
\n", + "
" + ], + "text/plain": [ + " Game \\\n", + "0 books/myerson1991/fig2_1 \n", + "1 books/myerson1991/fig4_2 \n", + "2 books/shohamleytonbrown2008/fig5_1 \n", + "3 books/shohamleytonbrown2008/fig5_10 \n", + "4 books/shohamleytonbrown2008/fig5_11 \n", + "5 books/shohamleytonbrown2008/fig5_12 \n", + "6 books/shohamleytonbrown2008/fig5_15 \n", + "7 books/shohamleytonbrown2008/fig5_2 \n", + "8 books/shohamleytonbrown2008/fig5_9 \n", + "9 books/shohamleytonbrown2008/fig6_2 \n", + "10 books/shohamleytonbrown2008/fig6_8 \n", + "11 books/vonstengel2022/fig10.1 \n", + "12 books/vonstengel2022/fig10.12 \n", + "13 books/vonstengel2022/fig10.5 \n", + "14 books/vonstengel2022/fig10.7 \n", + "15 books/watson2013/exercise29_6 \n", + "16 books/watson2013/fig29_1 \n", + "17 conf/itcs/jakobsen2016/fig1a \n", + "18 conf/itcs/jakobsen2016/fig1b \n", + "19 conf/itcs/jakobsen2016/fig1c \n", + "20 conf/itcs/jakobsen2016/fig3 \n", + "21 journals/geb/bagwell1995 \n", + "22 journals/geb/gilboa1997/fig1 \n", + "23 journals/geb/gilboa1997/fig2 \n", + "24 journals/geb/wichardt2008 \n", + "25 journals/ijgt/nau2004/sec3 \n", + "26 journals/ijgt/nau2004/sec4 \n", + "27 journals/ijgt/nau2004/sec5 \n", + "28 journals/ijgt/nau2004/sec6 \n", + "29 journals/ijgt/selten1975/fig1 \n", + "30 journals/ijgt/selten1975/fig2 \n", + "31 journals/ijgt/selten1975/fig3 \n", + "32 journals/mor/vonstengelforges2008/fig1 \n", + "33 journals/mor/vonstengelforges2008/fig6 \n", + "34 journals/mor/vonstengelforges2008/fig9 \n", + "35 journals/other/reiley2008/fig1 \n", + "36 journals/other/shapley1974/fig2 \n", + "37 journals/other/shapley1974/fig3 \n", + "\n", + " Title \n", + "0 A simple Poker game \n", + "1 Myerson (1991) Figure 4.2 \n", + "2 Fig 5.1 from Shoham and Leyton-Brown (2008) \n", + "3 Fig 5.10 from Shoham and Leyton-Brown (2008) \n", + "4 Fig 5.11 from Shoham and Leyton-Brown (2008) \n", + "5 Fig 5.12 from Shoham and Leyton-Brown (2008) \n", + "6 Fig 5.15 from Shoham and Leyton-Brown (2008) \n", + "7 Fig 5.2 from Shoham and Leyton-Brown (2008) \n", + "8 Fig 5.9 from Shoham and Leyton-Brown (2008) \n", + "9 Fig 6.2 from Shoham and Leyton-Brown (2008) \n", + "10 Fig 6.8 from Shoham and Leyton-Brown (2008) \n", + "11 Figure 10.1 from von Stengel (2022) \n", + "12 Figure 10.12 from von Stengel (2022) \n", + "13 Figure 10.5 from von Stengel (2022) \n", + "14 Figure 10.7 from von Stengel (2022) \n", + "15 Princess Bride signaling game (from Watson) \n", + "16 Job-market signaling game (version from Watson) \n", + "17 Jakobsen, Sorensen, Conitzer (2016) Figure 1(a) \n", + "18 Jakobsen, Sorensen, Conitzer (2016) Figure 1(b) \n", + "19 Jakobsen, Sorensen, Conitzer (2016) Figure 1(c) \n", + "20 Jakobsen, Sorensen, Conitzer (2016) Figure 3 \n", + "21 Bagwell (GEB 1995) commitment and (un)observab... \n", + "22 Absent-Minded Driver (Gilboa 1997, GEB, Figure 2) \n", + "23 Two-Selves Absent-Minded Driver (Gilboa 1997, ... \n", + "24 Wichardt (2008): 2 players, imperfect recall \n", + "25 Battle of the Sexes \n", + "26 Three-player game with a unique Nash solution ... \n", + "27 Game with a continuum of completely mixed-stra... \n", + "28 2x2x4 game with Nash equilibria in the relativ... \n", + "29 Selten's horse (Selten IJGT 1975, Figure 1) \n", + "30 Selten (IJGT 1975) Figure 2 \n", + "31 Selten (IJGT 1975) Figure 3 \n", + "32 Figure 1 from von Stengel and Forges (2008) \n", + "33 Figure 6 from von Stengel and Forges (2008) \n", + "34 Figure 9 from von Stengel and Forges (2008) \n", + "35 Stripped-down poker (Reiley et al 2008) \n", + "36 Fig 2 from 'A Note on the Lemke-Howson Algorit... \n", + "37 Fig 3 from 'A Note on the Lemke-Howson Algorit... " + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "catalog = NormalFormGame().load_from_gambit_catalog()\n", + "catalog" + ] + }, + { + "cell_type": "markdown", + "id": "f480f1f8", + "metadata": {}, + "source": [ + "Passing a name from the `Game` column loads that game.\n", + "Here is Bagwell's game on commitment and observability:" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "e871f78c", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-18T22:21:49.540399Z", + "iopub.status.busy": "2026-08-18T22:21:49.540319Z", + "iopub.status.idle": "2026-08-18T22:21:49.543673Z", + "shell.execute_reply": "2026-08-18T22:21:49.543367Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "Normal Form Game with the following utilities: {(0, 0): [5, 2],\n", + " (0, 1): [249/50, 199/100],\n", + " (0, 2): [151/50, 101/100],\n", + " (0, 3): [3, 1],\n", + " (1, 0): [6, 3],\n", + " (1, 1): [201/50, 399/100],\n", + " (1, 2): [299/50, 301/100],\n", + " (1, 3): [4, 4]}" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "bagwell = NormalFormGame()\n", + "bagwell.load_from_gambit_catalog(\"journals/geb/bagwell1995\", info=False)\n", + "bagwell" + ] + }, + { + "cell_type": "markdown", + "id": "4a0ef38f", + "metadata": {}, + "source": [ + "## Solving games\n", + "\n", + "`obtain_nash` is Sage's entry point to equilibrium computation.\n", + "Without an algorithm it picks a sensible default; with one, it dispatches either to Sage's own exact routines or to one of Gambit's solvers.\n", + "\n", + "Our test case is the Battle of the Sexes, which has two pure equilibria and one mixed one." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "72d366ce", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-18T22:21:49.544533Z", + "iopub.status.busy": "2026-08-18T22:21:49.544464Z", + "iopub.status.idle": "2026-08-18T22:21:49.588159Z", + "shell.execute_reply": "2026-08-18T22:21:49.587762Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "[[(0, 1), (0, 1)], [(3/4, 1/4), (1/4, 3/4)], [(1, 0), (1, 0)]]" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "battle = NormalFormGame([matrix([[3, 1], [0, 2]]),\n", + " matrix([[2, 1], [0, 3]])])\n", + "battle.obtain_nash()" + ] + }, + { + "cell_type": "markdown", + "id": "6b5ce8a5", + "metadata": {}, + "source": [ + "The default answer is *exact*: the mixed equilibrium comes out as `3/4` and `1/2`, not as decimals.\n", + "That is Sage's own vertex enumeration at work.\n", + "\n", + "Handing the same game to Gambit's solvers gives the same equilibria as floating point approximations.\n", + "`'enumeration'` stays in Sage, while `'LCP'` and `'enummixed'` are Gambit's.\n", + "(Sage also offers `'lrs'`, which uses the external `lrslib` package; it is not installed here, so it is left out of the comparison below.)" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "818b0d19", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-18T22:21:49.589218Z", + "iopub.status.busy": "2026-08-18T22:21:49.589125Z", + "iopub.status.idle": "2026-08-18T22:21:49.593095Z", + "shell.execute_reply": "2026-08-18T22:21:49.592756Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "enumeration [[(0, 1), (0, 1)], [(3/4, 1/4), (1/4, 3/4)], [(1, 0), (1, 0)]]\n", + "LCP [[(0.0, 1.0), (0.0, 1.0)], [(0.7499999999999999, 0.25), (0.24999999999999994, 0.7500000000000001)], [(1.0, 0.0), (1.0, 0.0)]]\n", + "enummixed [[(0.0, 1.0), (0.0, 1.0)], [(0.7499999999999999, 0.25), (0.24999999999999994, 0.7500000000000001)], [(1.0, 0.0), (1.0, 0.0)]]\n" + ] + } + ], + "source": [ + "for algorithm in [\"enumeration\", \"LCP\", \"enummixed\"]:\n", + " print(f\"{algorithm:12s}\", battle.obtain_nash(algorithm=algorithm))" + ] + }, + { + "cell_type": "markdown", + "id": "12fb5b1f", + "metadata": {}, + "source": [ + "So the two libraries are complementary here too: use Sage's solvers when you want exact answers on a small game, and Gambit's when the game is large enough that exact arithmetic becomes the bottleneck.\n", + "\n", + "Sage can also tell you whether the game is degenerate, which is worth checking before trusting an equilibrium count." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "17c23058", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-18T22:21:49.594083Z", + "iopub.status.busy": "2026-08-18T22:21:49.593996Z", + "iopub.status.idle": "2026-08-18T22:21:49.595875Z", + "shell.execute_reply": "2026-08-18T22:21:49.595596Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "False" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "battle.is_degenerate()" + ] + }, + { + "cell_type": "markdown", + "id": "089e7b2a", + "metadata": {}, + "source": [ + "## Games with more than two players\n", + "\n", + "A two player game is a pair of matrices, but a game with $n$ players needs $n$ payoff arrays of $n$ dimensions each, and a Sage matrix is only ever two dimensional.\n", + "For more than two players, pass NumPy arrays instead.\n", + "\n", + "Here is a three player consensus game: everybody picks one of two options, and everybody scores a point only if all three agree." + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "908a8a1a", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-18T22:21:49.596726Z", + "iopub.status.busy": "2026-08-18T22:21:49.596659Z", + "iopub.status.idle": "2026-08-18T22:21:49.599448Z", + "shell.execute_reply": "2026-08-18T22:21:49.599119Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "[[(0.0, 1.0), (0.0, 1.0), (0.0, 1.0)], [(1.0, 0.0), (1.0, 0.0), (1.0, 0.0)]]" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "agree = np.zeros((2, 2, 2), dtype=int)\n", + "agree[0, 0, 0] = 1\n", + "agree[1, 1, 1] = 1\n", + "\n", + "consensus = NormalFormGame([agree, agree, agree])\n", + "consensus.obtain_nash(algorithm=\"enumpure\")" + ] + }, + { + "cell_type": "markdown", + "id": "ab42b2c8", + "metadata": {}, + "source": [ + "Both \"everyone picks the first option\" and \"everyone picks the second\" are equilibria, as expected.\n", + "\n", + "This is where Gambit really earns its place: Sage's own solvers only handle two players, so every algorithm for larger games — `'gnm'`, `'enumpure'`, `'enumpoly'`, `'liap'`, `'simpdiv'`, `'ipa'` and `'logit'` — is Gambit's.\n", + "The default for a game with more than two players is `'enumpoly'`, which finds the mixed equilibrium too." + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "828a2894", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-18T22:21:49.600303Z", + "iopub.status.busy": "2026-08-18T22:21:49.600222Z", + "iopub.status.idle": "2026-08-18T22:21:49.606874Z", + "shell.execute_reply": "2026-08-18T22:21:49.606583Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "[[(0.0, 1.0), (0.0, 1.0), (0.0, 1.0)],\n", + " [(0.5, 0.5), (0.5, 0.5), (0.5, 0.5)],\n", + " [(1.0, 0.0), (1.0, 0.0), (1.0, 0.0)]]" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "consensus.obtain_nash()" + ] + }, + { + "cell_type": "markdown", + "id": "61546695", + "metadata": {}, + "source": [ + "## Plotting a game\n", + "\n", + "Sage can draw a two player game as a labelled payoff bimatrix, optionally marking each player's best responses and the pure equilibria." + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "15895aa1", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-18T22:21:49.607706Z", + "iopub.status.busy": "2026-08-18T22:21:49.607639Z", + "iopub.status.idle": "2026-08-18T22:21:49.891222Z", + "shell.execute_reply": "2026-08-18T22:21:49.890842Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "Graphics object consisting of 28 graphics primitives" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "battle.plot(player_labels=[\"Amy\", \"Bob\"],\n", + " strategy_labels=[[\"game\", \"movie\"], [\"game\", \"movie\"]],\n", + " best_responses=True, pure_nash=True)" + ] + }, + { + "cell_type": "markdown", + "id": "17f544c1", + "metadata": {}, + "source": [ + "## Case study 1: a game whose payoffs are symbols\n", + "\n", + "Everything so far could be described as file conversion. This is where the integration starts to pay for itself.\n", + "\n", + "Gambit's solvers work on numbers. Sage's symbolic ring works on *expressions*, and a `NormalFormGame` is perfectly happy to hold them. So we can write down a whole family of games at once and solve it in closed form.\n", + "\n", + "The example is Hawk–Dove. Two animals contest a resource worth $v$. Two doves split it; a hawk takes it from a dove; two hawks fight and share the value minus a cost $c$ of injury." + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "d041d5a4", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-18T22:21:49.892290Z", + "iopub.status.busy": "2026-08-18T22:21:49.892164Z", + "iopub.status.idle": "2026-08-18T22:21:49.915511Z", + "shell.execute_reply": "2026-08-18T22:21:49.915092Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "Normal Form Game with the following utilities: {(0, 0): [-1/2*c + 1/2*v, -1/2*c + 1/2*v],\n", + " (0, 1): [v, 0],\n", + " (1, 0): [0, v],\n", + " (1, 1): [1/2*v, 1/2*v]}" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "v, c, p = var(\"v c p\")\n", + "\n", + "H = matrix([[(v - c)/2, v],\n", + " [0, v/2]])\n", + "hawk_dove = NormalFormGame([H, H.transpose()])\n", + "hawk_dove" + ] + }, + { + "cell_type": "markdown", + "id": "fd8ee4e1", + "metadata": {}, + "source": [ + "In the mixed equilibrium each animal plays Hawk with some probability $p$ that leaves its opponent indifferent between the two behaviours.\n", + "We write that indifference condition down and ask Sage to solve it." + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "984ad51b", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-18T22:21:49.916545Z", + "iopub.status.busy": "2026-08-18T22:21:49.916463Z", + "iopub.status.idle": "2026-08-18T22:21:50.690092Z", + "shell.execute_reply": "2026-08-18T22:21:50.689644Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "[p == v/c]" + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "hawk = p*(v - c)/2 + (1 - p)*v\n", + "dove = (1 - p)*v/2\n", + "\n", + "solution = solve(hawk == dove, p)\n", + "solution" + ] + }, + { + "cell_type": "markdown", + "id": "76ef7676", + "metadata": {}, + "source": [ + "The equilibrium share of hawks is $p^* = v/c$ — a closed form valid for every $v$ and $c$ at once, which no numerical solver could have produced.\n", + "Being an ordinary Sage expression, we can now plot it, differentiate it, or take limits of it." + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "503b6b13", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-18T22:21:50.691171Z", + "iopub.status.busy": "2026-08-18T22:21:50.691084Z", + "iopub.status.idle": "2026-08-18T22:21:50.779731Z", + "shell.execute_reply": "2026-08-18T22:21:50.779340Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "Graphics object consisting of 1 graphics primitive" + ] + }, + "execution_count": 20, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "p_star = solution[0].rhs()\n", + "\n", + "plot(p_star.subs(v=2), (c, 2, 10), axes_labels=[\"cost $c$\", \"hawk share $p^*$\"],\n", + " thickness=2, gridlines=True)" + ] + }, + { + "cell_type": "markdown", + "id": "1ae76060", + "metadata": {}, + "source": [ + "And we can check the formula against Gambit.\n", + "Substituting $v = 2$, $c = 5$ turns the symbolic matrices into numeric ones, at which point the game converts and Gambit's `enummixed` solver applies." + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "5b711f6b", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-18T22:21:50.780896Z", + "iopub.status.busy": "2026-08-18T22:21:50.780787Z", + "iopub.status.idle": "2026-08-18T22:21:50.783635Z", + "shell.execute_reply": "2026-08-18T22:21:50.783278Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "[[(0.0, 1.0), (1.0, 0.0)],\n", + " [(0.39999999999999997, 0.6000000000000001),\n", + " (0.39999999999999997, 0.6000000000000001)],\n", + " [(1.0, 0.0), (0.0, 1.0)]]" + ] + }, + "execution_count": 21, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "numeric = NormalFormGame([H.subs(v=2, c=5),\n", + " H.transpose().subs(v=2, c=5)])\n", + "numeric.obtain_nash(algorithm=\"enummixed\")" + ] + }, + { + "cell_type": "markdown", + "id": "6ec1ea0f", + "metadata": {}, + "source": [ + "The middle equilibrium puts weight `0.39999999999999997` on Hawk. That is Gambit's floating point rendering of a number the formula gives us exactly:" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "40eff1c4", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-18T22:21:50.784600Z", + "iopub.status.busy": "2026-08-18T22:21:50.784499Z", + "iopub.status.idle": "2026-08-18T22:21:50.786672Z", + "shell.execute_reply": "2026-08-18T22:21:50.786358Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "2/5" + ] + }, + "execution_count": 22, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "p_star.subs(v=2, c=5)" + ] + }, + { + "cell_type": "markdown", + "id": "b1671913", + "metadata": {}, + "source": [ + "## Case study 2: from a graph to a game\n", + "\n", + "The second thing Sage brings is its library of mathematical objects. Here we turn a *graph* into a game and let Gambit analyse it.\n", + "\n", + "In the **max cut game**, every vertex of a graph is a player choosing one of two sides. A player's payoff is the number of its incident edges that end up cut, that is, joining vertices on opposite sides. A pure Nash equilibrium is exactly a cut that no single vertex can improve by switching sides — a *locally* optimal cut.\n", + "\n", + "We use the house graph: five vertices, six edges." + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "00206d88", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-18T22:21:50.787715Z", + "iopub.status.busy": "2026-08-18T22:21:50.787633Z", + "iopub.status.idle": "2026-08-18T22:21:50.892074Z", + "shell.execute_reply": "2026-08-18T22:21:50.891666Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAdUAAAHWCAYAAAAhLRNZAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjksIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvJkbTWQAAAAlwSFlzAAAPYQAAD2EBqD+naQAAGfJJREFUeJzt3X20VeV94PGfQABFcTSKNdEQFYwW8Ha4Nxkv0RF8iU264hozrliUdETRuBBXkzpxmk6caZd2maIkHaMYcRAcCdUuNZmYmYz1BWgdcLWAAXFqvCRpnFgNKqgjKkRg1nOSq8B9O+fe57zt8/n8w7rn7r3PuclKvmvv8+zfPmDPnj17AgAYsmFDPwQAIKoAkJEzVQDIRFQBIBNRBYBMRBUAMhFVAMhEVKFJ7N69u94fARiAqEKDWr9+fVx99dXR0d4eo0ePjuHDh5f+TT+n19PvgcZygIlK0Fg2b94cV1x+eaxYuTI+PO7IOLujLdomnhBjxxwUb2x/KzZ0/SQeXbshXtjycsyYPj0W3XlnTJgwod4fGxBVaCzLly+POXPmxNGHHxY3zbssPnvaqTFixPAe27377q546Ikn4yu3Lo4Xt26LxYsXx8yZM+vymYH3OVOFBgrqrFmzYta5Z8bCa6+OMQeOHnCf7W+/E3PnfyuWPfx4LFu2LC666KKafFagd75ThQbQ1dVVOkNNQV1y3TW9BvXGu++NYZ2/G1/65rffey1tl7ZP+6X906VjoH5EFRrAF6+4Ij70wcNKZ6jDhvX8n+U//J8fx53//YdxyoTjevwubZ/2S5eM03exQP2IKtTZunXrSouS5l91Wa9nqG++9XbM+tP5seiP/zAOO+TgXo+R9ps/79LScawKhvoRVaizpUuXxjFHjSstSurNvJtvi89M+0Sc/Ymp/R7nvNM6S6uFlyxZUqVPCgxkxIBbAFW1ZvXqOKv9lF5X+d77yMpY/+PN8fd33TLgcdL+Z7W3xZNr1lTpkwIDcaYKdbbpmWdK96Hu7//+8uXSoqR7/vTaGD1qZFnHapt4fDy9aVMVPiVQDmeqUOfRgzt27CgNdtjfume7Ysu216Jj9rz3Xtu1a3f87Y82xW0PfD/eWfVQacrS3g49eEzpeOm4vS14AqpLVKGOUvhGjRpVmpS0v7M6fic2Lnv/9pnk0j9fECeNPzaunfX5HkFNXn9ze+l4ggr1IapQZ5MnTSqNHtzfIWMOisknfHSf18aMHh2Hjx3b4/VuG7p+GlMmT67aZwX65/oQ1FnntGmlWb5p9OBQpP0fW7chTu3szPbZgMoYUwh1lu4rbW9vjwduvC7On/7JQR/nwZVPxAVfvaF03+vUqf3ffgNUh6hCAzhzxoz4edePY8M9t5c187e3GcBtX5gb4yeeGI+vWFGVzwgMzOVfaAALvvGNeP6lLXHlX9xS8cPI0/ZXzr8lXnx1a+kxcED9iCrU2RtvvBFz586NkaNGxfK/WRGzr19QOvMsR9rukusXxHf+1+Px4WOOiXHjxlX98wJ9E1Woc1DPPffcePbZZ2PVqlWlx7fdv2p16VJu+o60r8VL6fX0+7TdA6tWxw033BCvvPJK6VjpmEB9+E4VGiCojzzySHR0dJReT49vS0+bScPx0yzfNHowTUpKgx3Sfajptpm0yveFLS+Xvou9Y9GimDBhQqxduzbOOeecOOmkk+Lhhx+OsWPH+u8WakxUoYGCuv+q4DQcP83yTaMH06SkNNgh3YeabpuZPXt2j1W+wgr1JarQgEHtTbmjB4UV6kdUoQmCWilhhfqwUAkKFtQkHTu9R3ovi5egdkQVChbUbsIKtSeqUMCgdhNWqC1RhYIGtZuwQu2IKhQ4qN2EFWpDVKHgQe0mrFB9ogotENRuwgrVJarQIkHtJqxQPaIKLRTUbsIK1SGq0GJB7SaskJ+oQgsGtZuwQl6iCi0a1G7CCvmIKrRwULsJK+QhqtDiQe0mrDB0ogoVKmJQuwkrDI2oQgWKHNRuwgqDJ6pQplYIajdhhcERVShDKwW1m7BC5UQVBtCKQe0mrFAZUYV+tHJQuwkrlE9UoQ+C+j5hhfKIKvRCUHsSVhiYqMJ+BLVvwgr9E1XYi6AOTFihb6IKvyGo5RNW6J2ogqAOirBCT6JKy3OGOnjCCvsSVVqaoA6dsML7RJWWJaj5CCv8mqjSkgQ1P2EFUaUFCWr1CCutzpkqLUVQq09YaWWiSssQ1NoRVlqVqNISBLX2hJVWJKoUnqDWj7DSakSVQhPU+hNWWomoUliC2jiElVYhqhSSoDYeYaUViCqFI6iNS1gpOlGlUAS18QkrRSaqFIagNg9hpahElUIQ1OYjrBSRqNL0BLV5CStFI6o0NUFtfsJKkYgqTUtQi0NYKQpRpSkJavEIK0UgqjQdQS0uYaXZiSpNRVCLT1hpZqJK0xDU1iGsNCtRpSkIausRVpqRqNLwBLV1CSvNRlRpaIKKsNJMRJWGJah0E1aahajSkASV/QkrzUBUaTiCSl+ElUYnqjQUQWUgwkojE1UahqBSLmGlUYkqDUFQqZSw0ohElboTVAZLWGk0okpdCSpDJaw0ElGlbgSVXISVRiGq1IWgkpuw0ghElZoTVKpFWKk3UaWmBJVqE1bqSVSpGUGlVoSVehFVakJQqTVhpR5ElaoTVOpFWKk1UaWqBJV6E1ZqSVSpGkGlUQgrtSKqVIWg0miElVoQVbITVBqVsFJtokpWgkqjE1aqSVTJRlBpFsJKtYgqWQgqzUZYqQZRZcgElWYlrOQmqgyJoNLshJWcRJVBE1SKQljJRVQZFEGlaISVHESVigkqRSWsDJWoUhFBpeiElaEQVcomqLQKYWWwRJWyCCqtRlgZDFFlQIJKqxJWKiWq9EtQaXXCSiVElT4JKvyasFIuUaVXggr7ElbKIar0IKjQO2FlIKLKPgQV+ies9EdUeY+gQnmElb6IKiWCCpURVnojqggqDJKwsj9RbXHOUGFohJW9iWoLE1TIQ1jpJqotSlAhL2ElEdUWJKhQHcKKqLYYQYXqEtbWJqotRFChNoS1dYlqixBUqC1hbU2i2gIEFepDWFuPqBacoEJ9CWtrEdUCE1RoDMLaOkS1oAQVGouwtgZRLSBBhcYkrMUnqgUjqNDYhLXYRLVABBWag7AWl6gWhKBCcxHWYhLVAhBUaE7CWjyi2uQEFZqbsBaLqDYxQYViENbiENUmJahQLMJaDKLahAQViklYm5+oNhlBhWIT1uYmqk1EUKE1CGvzEtUmIajQWoS1OYlqExBUaE3C2nxEtcEJKrQ2YW0uotrABBVIhLV5iGqDElRgb8LaHES1AQkq0BthbXyi2mAEFeiPsDY2UW0gggqUQ1gbl6g2CEEFKiGsjUlUG4CgAoMhrI1HVOtMUIGhENbGIqp1JKhADsLaOES1TgQVyElYG4Oo1oGgAtUgrPUnqjUmqEA1CWt9iWoNCSpQC8JaP6JaI4IK1JKw1oeo1oCgAvUgrLUnqlUmqEA9CWttiWoVCSrQCIS1dkS1SgQVaCTCWhuiWgWCCjQiYa0+Uc1MUIFGJqzVJaoZCSrQDIS1ekQ1E0EFmomwVoeoZiCoQDMS1vxEdYgEFWhmwpqXqA6BoAJFIKz5iOogCSpQJMKah6gOgqACRSSsQyeqFRJUoMiEdWhEtQKCCrQCYR08US2ToAKtRFgHR1TLIKhAKxLWyonqAAQVaGXCWhlR7YegAghrJUS1D4IK8D5nrOUR1V4IKkBPwjowUd2PoAL0TVj7J6p7EVSAgQlr30T1NwQVoHzC2jtRFVSAQRHWnlo+qs5QAQZPWPfV0lEVVIChE9b3tWxUBRUgH2Ft4agKKkB+HR0d8cgjj8Szzz4b5557bun/a1tNy0VVUAGqp6PFw9pSURVUgOrraOGwtkxUBRWgdjpaNKwtEVVBBai9jhYMa+GjKqgA9dPRYmEtdFQFFaD+OloorIWNqqACNI6OFglrIaMqqACNp6MFwlq4qAoqQOPqKHhYCxVVQQVofB0FDmthoiqoAM2jo6BhLURUBRWg+XQUMKxNH1VBBWheHQULa1NHVVABml9HgcLatFEVVIDi6ChIWJsyqoIKUDwdBQhr00VVUAGKq6PJw9pUURVUgOLraOKwNk1UBRWgdXQ0aVibIqqCCtB6OpowrA0fVUEFaF0dTRbWho6qoALQ0URhbdioCioAzRbWhoyqoALQjGFtuKgKKgDNGtaGiqqgAtDMYW2YqAoqAM0e1oaIqqACUISw1j2qggpAUcJa16gKKgBFCmvdoiqoABQtrHWJqqACUMSw1jyqggpAUcOaNaq7d+/u9/eCCkAjhnWgftUkquvXr4+rr746OtrbY/To0TF8+PDSv+nn9Hr6fTdBBaBRwlpJvypxwJ49e/ZUutPmzZvjissvjxUrV8aHxx0ZZ3e0RdvEE2LsmIPije1vxYaun8SjazfEC1tejhnTp8eCb3wj5s6dW/rj0h+Z/lgAqLa1a9fGOeecEyeddFI8/PDDsWXLlor6tejOO2PChAnVi+ry5ctjzpw5cfThh8VN8y6Lz552aowYMbzHdu++uyseeuLJ+Mqt/zWef2lLjBw1KlatWiWoANQlrEcccUS88ItfxNEfPLzMfi2OF7dui8WLF8fMmTPzX/5NQZ01a1ZccMa02HDPwjh/+id7/UBJej39fsM9t8eFZ58Rb7/9djz33HOVvB0ADFm6OnrNNdeUrrJ+bnol/VpY6t3FF19c6l/WM9Wurq5oa2srvcGS666JYcOGxY133xvfXfW/49mf/yIOHDUypk357fj63EvjY+OP7fEF8OzrF8T9q1bHxo0bKzqVBoCh6O7Xvz1jWiz9Tb+S2x/8QXz7wR/EP724pfTzpOM/EtddenF8uvPjg+5X2VE9c8aMeH7zc/Gj/7Ywxhw4uvTap7/0H+PCc86Ij598Yry7a3d87dtL4+mf/lM8s3zRe9t02/72O9H2hbkxfuKJ8fiKFZX/pwIAg9Bbv5KH/u7JGD58WEw45kOln+/+n4/Gzd+5P9bffWtMOv6jg+pXWVFdt25d6fT5gRuvK50S9+Xlba/FUZ/5/Vi58Kb41/9ySo/fP7jyibjgqzeUjjd16tSB3hYAhqTcfnX74KcuiPnz5sRl5/3uoPpV1neqS5cujWOOGlf6Urc/r7/5Vunfw8ce0uvvzzuts7TaasmSJeW8LQAMSbn92rVrV9z7yMrY/s6O6Jxy8qD7NaKcD7Vm9eo4q/2UPr/UTdIJ7zW33BGntU2KySd8tPc3GzE8zmpviyfXrCnnbQFgSAbq19ObfxbTrvhyvLNzZxx84IHx4Nevi98+bvyg+1VWVDc980xcfPol/W4z7+bbYuPmn8Xf3bGg3+3aJh4f9z62dNA31gJAuZ7etCkuPn12n7//2Phj4qm7F8Zrb74ZD6x4Ii65fkGsXDi/17Cmft33+N1Di2pa+bRjx47SjbF9uXrBwtI9PatuvzmOGXdkv8c79OAxsXPnzmhvbx/orQFgyPrr18gPfCAmHPvrhUodJ58Ya//xufgv930v7vjjP+y1X6mHqYvdK4grjmracdSoUaVJE71d8k1B/d6q1bFi4fw47kO/NdDh4vU3t8fIkSNjjUvAAFRZZ2dnr/3qS1q6u/NXv+qzX6mHfQW17Mu/kydNKo1u2t9VN98Wf/U3K+J7f/Gf45CDDoyXXt1aev3QMWPiwNGjej3Whq6fxilTplj9C0DVTZk8udd+JX9y+5LSPanHHnVE/L/tb8e9j66KlU9tjB9+84Y++5WO15+yoto5bVp896/vK41u2vvL3nTTbDLjqmv32f6ur/1RXPJ7n+pxnLT/Y+s2xPmfv7CctwWAIemrX8kvt26LP/iz+fHiq9vi0IMPilNOOK4U1HM+MXXQ/SrrPtW0qCh9B1rufT59cZ8qALVU635VNFHp513PlWYh7j8tqRwmKgFQD7XsV9kD9dPjb9K0/rnzv1Xxw1zT9mm/tH86DgDUSi37VXZU0xDh9PibZQ8/XhounMpdjrRd2j7tl/Y3TB+AWqplv4b0PNX58y4tjW7q63l0339iTVx7610VP48OAHKrRb8qjmqSnkm395PT0+imNGki3Rib7uNJy47TKqn05PR0LfuORYucoQJQd9Xu16CiuveqqjRcOM1C3Pj006VJSWmwQ7oP9dTOzpg9e7b7UQFoONXq15Ci2tuyZY91A6CZ5OxX2QuVAID+iSoAZCKqAJCJqAJAJqIKAJmIKgBkIqoAkImoAkAmogoAmYgqAGQiqgCQiagCQCaiCgCZiCoAZCKqAJCJqAJAJqIKAJmIKgBkIqoAkImoAkAmogoAmYgqAGQiqgCQiagCQCaiCgCZiCoAZCKqAJCJqAJAJqIKAJmIKgBkIqoAkImoAkAmogoAmYgqAGQiqgCQiagCQCaiCgCZiCoAZCKqAJCJqAJAJqIKAJmIKgBkIqoAkImoAkAmogoAmYgqAGQiqgCQiagCQCaiCgCZiCoAZCKqAJCJqAJAJqIKAJmIKgBkIqoAkImoAkAmogoAmYgqAGQiqgCQiagCQCaiCgCZiCoAZCKqAJCJqAJAJqIKAJmIKgBkIqoAkImoAkAmogoAmYgqAGQiqgCQiagCQCaiCgCZiCoAZCKqAJCJqAJAJqIKAJmIKgBkIqoAkImoAkAmogoAmYgqAGQiqgCQiagCQCaiCgCZiCoAZCKqAJCJqAJAJqIKAJmIKgBkIqoAkImoAkAmogoAmYgqAGQiqgCQiagCQCaiCgCZiCoAZCKqAJCJqAJAJqIKAJmIKgBkIqoAkImoAkAmogoAmYgqAGQiqgCQiagCQCaiCgCZiCoAZCKqAJCJqAJAJqIKAJmIKgBkIqoAkImoAkAmogoAmYgqAGQiqgCQiagCQCaiCgCZiCoAZCKqAJCJqAJAJqIKAJmIKgBkIqoAkImoAkAmogoAmYgqAGQiqgCQiagCQCaiCgCZiCoAZCKqAJCJqAJAJqIKAKIKAI3FmSoAZCKqAJCJqAJAJqIKAJmIKgBkIqoAkImoAkAmogoAmYgqAGQiqgCQiagCQCaiCgCZiCoAZCKqAJCJqAJAJqIKAJmIKgBkIqoAkImoAkAmogoAmYgqAGQiqgCQiagCQCaiCgCZiCoAZCKqAJCJqAJAJqIKAJmIKgBkIqoAkImoAkAmogoAmYgqAGQiqgAgqgDQWJypAkAmogoAmYgqAGQiqgCQiagCQCaiCgCZiCoAZCKqAJCJqAJAJqIKAJmIKgBkIqoAkImoAkAmogoAmYgqAGQiqgCQiagCQCaiCgCZiCoAZCKqAJCJqAJAJgfs2bNnz2B3Xr9+fSxZsiTWrF4dT2/aFDt37oyRI0fGlMmTo3PatJg9e3ZMnTo112cFgCyq1a9BRXXz5s1xxeWXx4qVK+PD446Mszvaom3iCTF2zEHxxva3YkPXT+LRtRvihS0vx4zp02PRnXfGhAkTKv5wAJBTtftVcVSXL18ec+bMiaMPPyxumndZfPa0U2PEiOE9tnv33V3x0BNPxlduXRwvbt0WixcvjpkzZ1byVgCQTS36VVFU0weaNWtWzDr3zFh47dUx5sDRA+6z/e13Yu78b8Wyhx+PZcuWxUUXXVTu2wFAFrXqV9lR7erqira2trjgjGmx5LprYtiw99c4LXzgobj5O/fHi69ujUnHjY9vfunKOP13Jr/3+927d8fs6xfE/atWx8aNG10KBqBm+urX3z71dKld637cFS++sjUe/Pp/in9zxrR99q20X2Wv/v3iFVfEhz54WKnwewf1vkdXxZf/8o74k0t+P9bffVuc1jY5PvNHX4vnX9ry/psMG1baL51yp2vZAFArffVr+zvvxCkTj4tvXTO3z30r7VdZUV23bl3pS935V13W45T5m3/1YFz62XNjznmfjpM/+pH4yy9fGceOOzJuf/AH+2yX9ps/79LScdKqKwCotv769enOj8cNX7wkPjf9tH6PUUm/yorq0qVL45ijxpW+1N3bzl/9qnTa/KlP7Lvs+Jx/NTXWPP2PPY5z3mmdpdVWaRkzAFRbX/2qVLn9Kiuq6T6es9pP6bFK6pXX3ohdu3bHUYcfts/rRx12WLy0dWuP46T9z2pviyfXrCnvrwCAIeirX5Uqt18jyjnYpmeeiYtPv6TP3x9wwL4/74k9cUDs9+JvtE08Pu59bKlLwABUXRrscPHps7McK/XrvsfvHlpU08qnHTt2lG6M3d8R/2JsDB8+LF56dds+r2/Z9lqPs9duhx48pjS5or29feC/AACGqLd+DUbqV+ph6uLeC54qimracdSoUaVJE/sb+YEPRPvHJsYj//BUnD/9k++9/ujfPxXnnd779evX39xeGgW1xiVgAKqss7Oz134NRupX6mFfQS378u/kSZNKo5t68+WZn4s/+LObouOkidE55eRY9L0fxvO/3BJXnv97vW6/oeunccqUKWYCA1B1aZZvX/168623Y/Mv/vm9n3/2zy/Fj577SRw+9pD4yG+N67Vf6Xj9KSuqabjwd//6vtLopv2/7L3w7DPi1dffiOvv+k68+Oq2mHz8+PgfC66P8Ucf1eM4af/H1m2I8z9/YTlvCwBD0l+/1j77XJx51X947+drbllU+vfffebsWHLdvx9Uv8qaqJTuy0nfgT5w43X7XOat1IMrn4gLvnpD6b4hT68BoNpq3a+yxxSeOWNG/Lzrudhwz8KyZib2NkOx7QtzY/zEE+PxFSsq3h8ABqOW/Sp7TGF6/E2a1p+GC6eVT5VI26f90v7pOABQK7XsV9lRTUOE0+Nv0rT+NFw4lbscabu0fdov7e+5qgDUUi37NaTnqaZZiGl0U1/Po/v+E2vi2lvv8jxVAOquFv2qOKq9PTk9jW5KkybSjbHpPp607DitkkpPTk/Xsu9YtMgZKgB1V+1+DSqqe6+qSsOF0yzENAoqTZpIN8am+3hO7eyM2bNnW+ULQMOpVr+GFNX99Te6CQAaVa5+ZY0qALQyp5UAkImoAkAmogoAmYgqAGQiqgCQiagCQOTx/wFAUiP/D39g5wAAAABJRU5ErkJggg==", + "text/plain": [ + "Graphics object consisting of 12 graphics primitives" + ] + }, + "execution_count": 23, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "G = graphs.HouseGraph()\n", + "G.plot(vertex_labels=True)" + ] + }, + { + "cell_type": "markdown", + "id": "6a1a0d3c", + "metadata": {}, + "source": [ + "Building the game is a matter of filling in one payoff array per vertex.\n", + "Sage's graph API supplies the vertices and the neighbours, and NumPy holds the payoffs." + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "id": "81e592cd", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-18T22:21:50.893203Z", + "iopub.status.busy": "2026-08-18T22:21:50.893115Z", + "iopub.status.idle": "2026-08-18T22:21:50.896394Z", + "shell.execute_reply": "2026-08-18T22:21:50.896045Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "5" + ] + }, + "execution_count": 24, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "def max_cut_game(graph):\n", + " \"\"\"Return the max cut game of ``graph`` as a Sage ``NormalFormGame``.\"\"\"\n", + " vertices = sorted(graph.vertices())\n", + " arrays = [np.zeros((2,) * len(vertices), dtype=int) for _ in vertices]\n", + " for profile in itertools.product([0, 1], repeat=len(vertices)):\n", + " side = dict(zip(vertices, profile, strict=True))\n", + " for i, u in enumerate(vertices):\n", + " arrays[i][profile] = sum(1 for w in graph.neighbors(u)\n", + " if side[w] != side[u])\n", + " return NormalFormGame(arrays)\n", + "\n", + "\n", + "game = max_cut_game(G)\n", + "len(game.players)" + ] + }, + { + "cell_type": "markdown", + "id": "a360b077", + "metadata": {}, + "source": [ + "Five players, so this is squarely in Gambit's territory. `'enumpure'` enumerates the pure equilibria." + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "id": "0ec6a91b", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-18T22:21:50.897383Z", + "iopub.status.busy": "2026-08-18T22:21:50.897306Z", + "iopub.status.idle": "2026-08-18T22:21:50.900154Z", + "shell.execute_reply": "2026-08-18T22:21:50.899764Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "6" + ] + }, + "execution_count": 25, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "equilibria = game.obtain_nash(algorithm=\"enumpure\")\n", + "len(equilibria)" + ] + }, + { + "cell_type": "markdown", + "id": "638113c9", + "metadata": {}, + "source": [ + "Now we read each equilibrium back as a cut and measure it — and here Sage answers a question Gambit cannot even be asked, by computing the true maximum cut exactly." + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "id": "cddb87cf", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-18T22:21:50.901105Z", + "iopub.status.busy": "2026-08-18T22:21:50.901021Z", + "iopub.status.idle": "2026-08-18T22:21:50.903833Z", + "shell.execute_reply": "2026-08-18T22:21:50.903489Z" + } + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
equilibriumedges cut
\\(\\left(0, 0, 1, 1, 0\\right)\\)\\(4\\)
\\(\\left(0, 1, 1, 0, 0\\right)\\)\\(5\\)
\\(\\left(0, 1, 1, 0, 1\\right)\\)\\(5\\)
\\(\\left(1, 0, 0, 1, 0\\right)\\)\\(5\\)
\\(\\left(1, 0, 0, 1, 1\\right)\\)\\(5\\)
\\(\\left(1, 1, 0, 0, 1\\right)\\)\\(4\\)
\n", + "
" + ], + "text/plain": [ + " equilibrium edges cut\n", + "├─────────────────┼───────────┤\n", + " (0, 0, 1, 1, 0) 4\n", + " (0, 1, 1, 0, 0) 5\n", + " (0, 1, 1, 0, 1) 5\n", + " (1, 0, 0, 1, 0) 5\n", + " (1, 0, 0, 1, 1) 5\n", + " (1, 1, 0, 0, 1) 4" + ] + }, + "execution_count": 26, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "def cut_size(profile):\n", + " return sum(1 for (u, w) in G.edges(labels=False) if profile[u] != profile[w])\n", + "\n", + "\n", + "profiles = sorted({tuple(int(round(s[1])) for s in eq) for eq in equilibria})\n", + "table([(profile, cut_size(profile)) for profile in profiles],\n", + " header_row=[\"equilibrium\", \"edges cut\"])" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "id": "d5c499a1", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-18T22:21:50.904771Z", + "iopub.status.busy": "2026-08-18T22:21:50.904693Z", + "iopub.status.idle": "2026-08-18T22:21:50.958370Z", + "shell.execute_reply": "2026-08-18T22:21:50.958014Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "5" + ] + }, + "execution_count": 27, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "G.max_cut(value_only=True)" + ] + }, + { + "cell_type": "markdown", + "id": "adcb2c9d", + "metadata": {}, + "source": [ + "Four of the six equilibria achieve the optimum of five cut edges, but two of them get stuck at four.\n", + "Those are the locally stable cuts that are not globally optimal, and the ratio $4/5$ is this game's price of anarchy.\n", + "\n", + "Gambit found the equilibria; Sage certified which of them were actually good. Neither library could have produced that sentence alone.\n", + "\n", + "## Summary\n", + "\n", + "| Task | Call |\n", + "|---|---|\n", + "| Gambit game to Sage | `NormalFormGame(game)` |\n", + "| Sage game to Gambit | `game._gambit_()` |\n", + "| Read and write `.nfg` | `game.load_nfg(path)`, `game.save_nfg(path)` |\n", + "| Browse and load catalog games | `game.load_from_gambit_catalog()` |\n", + "| Solve with Sage (exact, two players) | `game.obtain_nash(algorithm='enumeration')` |\n", + "| Solve with Gambit | `game.obtain_nash(algorithm='LCP')` and friends |\n", + "| Solve with more than two players | `game.obtain_nash(algorithm='enumpoly')` |\n", + "| Draw the payoff bimatrix | `game.plot()` |\n", + "\n", + "For games in extensive form — trees, information sets, and chance moves — see the companion tutorial, [Using Gambit with SageMath: extensive form games](sagemath_extensive_form.ipynb).\n", + "\n", + "Further reading:\n", + "\n", + "- [SageMath game theory reference](https://doc.sagemath.org/html/en/reference/game_theory/index.html)\n", + "- [PyGambit API documentation](https://gambitproject.readthedocs.io/en/latest/pygambit.api.html)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "SageMath", + "language": "sage", + "name": "sagemath" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.13" + }, + "nbsphinx": { + "execute": "never" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/pyproject.toml b/pyproject.toml index e2e4e55f2..4c4698000 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -86,6 +86,12 @@ unfixable = [] # Allow unused variables when underscore-prefixed. dummy-variable-rgx = "^(_+|(_+[a-zA-Z0-9_]*[a-zA-Z0-9]+?))$" +[tool.ruff.lint.per-file-ignores] +# The SageMath tutorials run on the SageMath Jupyter kernel, which injects Sage's +# globals (NormalFormGame, matrix, QQ, plot, ...) into every cell, so ruff cannot +# see where those names come from. +"doc/tutorials/interoperability_tutorials/sagemath_*.ipynb" = ["F821"] + [tool.ruff.format] quote-style = "double" indent-style = "space" diff --git a/tests/test_tutorials.py b/tests/test_tutorials.py index 6d6a4bb9e..cffd1a1a1 100644 --- a/tests/test_tutorials.py +++ b/tests/test_tutorials.py @@ -1,4 +1,5 @@ import contextlib +import functools import os import sys from pathlib import Path @@ -35,6 +36,14 @@ def _find_tutorial_notebooks(): return notebooks +@functools.lru_cache(maxsize=1) +def _available_kernels(): + """Return the set of Jupyter kernel names installed on this machine.""" + from jupyter_client.kernelspec import KernelSpecManager + + return set(KernelSpecManager().find_kernel_specs()) + + # Discover notebooks at import time so pytest can parametrize them. _NOTEBOOKS = _find_tutorial_notebooks() @@ -62,6 +71,15 @@ def test_execute_notebook(nb_path): # Prefer the notebook's kernelspec if provided, otherwise let nbclient pick the default. kernel_name = nb.metadata.get("kernelspec", {}).get("name") + # Notebooks for other systems (e.g. the SageMath tutorials, which declare the + # "sagemath" kernel) can only be executed where that kernel is installed. + # Their outputs are pre-saved for docs builds, so skip rather than fail. + if kernel_name and kernel_name not in _available_kernels(): + pytest.skip( + f"Notebook {nb_path.name} needs the {kernel_name!r} Jupyter kernel, " + "which is not installed" + ) + client = NotebookClient( nb, timeout=600, @@ -78,3 +96,36 @@ def test_execute_notebook(nb_path): # Ensure kernel is shut down. with contextlib.suppress(Exception): client.shutdown_kernel() + + +@pytest.mark.tutorials +@pytest.mark.parametrize("nb_path", _NOTEBOOKS, ids=[p.name for p in _NOTEBOOKS]) +def test_prerendered_notebooks_keep_outputs(nb_path): + """Notebooks the docs build cannot execute must ship their stored outputs. + + ``nbsphinx`` only executes notebooks that have no stored outputs, so tutorials that + cannot run on Read the Docs (no Java for GAMUT, no SageMath for the Sage tutorials) + opt out with ``"nbsphinx": {"execute": "never"}`` and commit their outputs instead. + If those outputs are ever stripped, the notebook silently renders as bare code with + no results at all, which is easy to miss when reviewing a docs build. + """ + nb = nbformat.read(str(nb_path), as_version=4) + kernel_name = nb.metadata.get("kernelspec", {}).get("name") + prerendered = nb.metadata.get("nbsphinx", {}).get("execute") == "never" + + # The docs build only has a plain Python kernel, so anything else must opt out. + if kernel_name and kernel_name != "python3": + assert prerendered, ( + f"{nb_path.name} declares the {kernel_name!r} kernel, which the docs build " + 'does not have. Set notebook metadata "nbsphinx": {"execute": "never"} and ' + "commit the notebook with its outputs." + ) + + if not prerendered: + pytest.skip(f"{nb_path.name} is executed during the docs build") + + code_cells = [cell for cell in nb.cells if cell.cell_type == "code"] + assert any(cell.get("outputs") for cell in code_cells), ( + f"{nb_path.name} sets nbsphinx execute='never' but has no stored outputs, so it " + "would render without any results. Re-run the notebook and commit it." + ) From fc5c76861fbb6bfc43598f65af3ec888a4a9b510 Mon Sep 17 00:00:00 2001 From: Amelie Kleber Date: Thu, 20 Aug 2026 21:26:24 +0200 Subject: [PATCH 2/3] tutorial corrections --- .../sagemath_extensive_form.ipynb | 179 ++++++++------- .../sagemath_normal_form.ipynb | 203 ++++++++---------- 2 files changed, 186 insertions(+), 196 deletions(-) diff --git a/doc/tutorials/interoperability_tutorials/sagemath_extensive_form.ipynb b/doc/tutorials/interoperability_tutorials/sagemath_extensive_form.ipynb index 6ed65ef8d..d25ea1854 100644 --- a/doc/tutorials/interoperability_tutorials/sagemath_extensive_form.ipynb +++ b/doc/tutorials/interoperability_tutorials/sagemath_extensive_form.ipynb @@ -4,7 +4,20 @@ "cell_type": "markdown", "id": "fd12d347", "metadata": {}, - "source": "# Using Gambit with SageMath: extensive form games\n\nA strategic form game is a table of payoffs. An **extensive form game** is a tree: players move in sequence, chance may intervene, and a player may be unable to tell apart the situations they find themselves in.\n\nSageMath's `ExtensiveFormGame` is a thin layer over Gambit's tree games. The tree itself, the information sets, and the equilibrium solvers are all Gambit's; what Sage adds is its own notation, exact rational arithmetic, plotting, and the rest of a computer algebra system.\n\nThis tutorial builds a few trees, walks through the interface, and ends with a puzzle that Gambit's solvers deliberately refuse to answer — and that Sage can settle exactly.\n\nThe companion tutorial [Using Gambit with SageMath: strategic form games](sagemath_normal_form.ipynb) covers `NormalFormGame` and the strategic form interface.\n\n> **Requirements.** As for the companion tutorial: a SageMath build containing [sagemath/sage#42367](https://github.com/sagemath/sage/pull/42367), the optional `pygambit` package, and the **SageMath kernel**.\n> The `gtdraw` section additionally needs the optional `gtdraw` package and a LaTeX installation." + "source": [ + "# Using Gambit with SageMath: extensive form games\n", + "\n", + "A strategic form game is a table of payoffs. An **extensive form game** is a tree: players move in sequence, chance may intervene, and a player may be unable to tell apart the situations they find themselves in.\n", + "\n", + "SageMath's `ExtensiveFormGame` is a thin layer over Gambit's tree games. The tree itself, the information sets, and the equilibrium solvers are all Gambit's; what Sage adds is its own notation, exact rational arithmetic, plotting, and the rest of a computer algebra system.\n", + "\n", + "This tutorial builds a few trees, walks through the interface, and ends with a puzzle that can be solved only by Sage.\n", + "\n", + "The companion tutorial [Using Gambit with SageMath: strategic form games](sagemath_normal_form.ipynb) covers `NormalFormGame` and the strategic form interface.\n", + "\n", + "> **Requirements.** As for the companion tutorial: a SageMath build containing [sagemath/sage#42367](https://github.com/sagemath/sage/pull/42367), the optional `pygambit` package, and the **SageMath kernel**.\n", + "> The `gtdraw` section additionally needs the optional `gtdraw` package and a LaTeX installation." + ] }, { "cell_type": "code", @@ -34,7 +47,7 @@ "\n", "We build the Battle of the Sexes as a sequential game: Amy chooses first, Bob sees what she chose and responds.\n", "\n", - "Two things are worth knowing before we start. Nodes carry **no labels** — following Gambit, a node is identified by the path of action labels leading to it, so `root.children['game']` is the node reached when Amy plays `game`. And an outcome is attached with `set_outcome`, which takes a label and the list of payoffs." + "Two things are worth knowing before we start. A node is identified by the path of action labels leading to it, so `root.children['game']` is the node reached when Amy plays `game`. And an outcome is attached with `set_outcome`, which takes a label and the list of payoffs." ] }, { @@ -83,7 +96,7 @@ "id": "15e1547c", "metadata": {}, "source": [ - "Because Bob observes Amy's choice, he is at a different decision point in each branch. That gives three information sets — one for Amy and one for each of Bob's two nodes — each containing a single node." + "Because Bob observes Amy's choice, he is at a different decision point in each branch. That gives three information sets, one for Amy and one for each of Bob's two nodes, each containing a single node." ] }, { @@ -121,7 +134,7 @@ "source": [ "## Drawing the tree\n", "\n", - "`plot` draws the tree. The default backend uses Sage's own graphics, so it works anywhere Sage does." + "`plot` draws the tree. You can choose to use Sage's own graphics, so it works anywhere Sage does. Because Bob's two decision nodes are in two different infosets, they are numbered based on which infoset they belong to." ] }, { @@ -208,7 +221,7 @@ { "data": { "image/svg+xml": [ - "\n", + "\n", "\n", "\n", "\n", @@ -245,135 +258,139 @@ "\n", "\n", "\n", - "\n", + "\n", "\n", "\n", - "\n", + "\n", "\n", "\n", - "\n", + "\n", "\n", "\n", - "\n", + "\n", "\n", "\n", "\n", "\n", - "\n", - "\n", + "\n", + "\n", "\n", "\n", - "\n", + "\n", "\n", - "\n", + "\n", "\n", - "\n", - "\n", - "\n", + "\n", + "\n", + "\n", "\n", "\n", - "\n", + "\n", "\n", "\n", - "\n", - "\n", - "\n", + "\n", + "\n", + "\n", "\n", - "\n", + "\n", "\n", - "\n", + "\n", "\n", "\n", - "\n", + "\n", "\n", "\n", - "\n", + "\n", "\n", "\n", - "\n", - "\n", - "\n", + "\n", + "\n", + "\n", "\n", - "\n", + "\n", "\n", - "\n", + "\n", "\n", "\n", - "\n", + "\n", "\n", "\n", - "\n", - "\n", + "\n", + "\n", "\n", "\n", - "\n", - "\n", - "\n", + "\n", + "\n", + "\n", "\n", - "\n", + "\n", "\n", - "\n", - "\n", - "\n", + "\n", + "\n", + "\n", "\n", "\n", - "\n", - "\n", + "\n", + "\n", "\n", "\n", - "\n", - "\n", - "\n", + "\n", + "\n", + "\n", "\n", - "\n", + "\n", "\n", - "\n", + "\n", "\n", "\n", - "\n", + "\n", "\n", "\n", - "\n", + "\n", "\n", "\n", - "\n", - "\n", - "\n", + "\n", + "\n", + "\n", "\n", - "\n", + "\n", "\n", - "\n", + "\n", "\n", "\n", - "\n", + "\n", "\n", "\n", - "\n", - "\n", + "\n", + "\n", "\n", "\n", - "\n", - "\n", - "\n", + "\n", + "\n", + "\n", "\n", - "\n", - "\n", - "\n", + "\n", + "\n", + "\n", "" ], "text/plain": [ "" ] }, - "execution_count": 6, "metadata": {}, - "output_type": "execute_result" + "output_type": "display_data" } ], "source": [ + "from shutil import which\n", + "\n", "from IPython.display import SVG\n", "\n", - "SVG(filename=picture.svg(view=False))" + "if which(\"pdflatex\") and which(\"pdftocairo\"):\n", + " display(SVG(filename=picture.svg(view=False)))\n", + "else:\n", + " print(\"pdflatex and pdftocairo are not both on PATH; skipping the rendering.\")" ] }, { @@ -433,7 +450,7 @@ "id": "7ba40bdc", "metadata": {}, "source": [ - "Two information sets now, one of which contains two nodes. Sage can also confirm that the game has perfect recall, meaning no player ever forgets something they previously knew — an assumption every one of Gambit's solvers relies on." + "Two information sets now, one of which contains two nodes. Sage can also confirm that the game has perfect recall, meaning no player ever forgets something they previously knew which is an assumption every one of Gambit's solvers relies on." ] }, { @@ -524,7 +541,7 @@ "\n", "Real games often start with a deal, a roll, or some other move by nature. `append_chance_move` adds one, with exact rational probabilities.\n", "\n", - "Here is a miniature poker game. Nature deals Alice a high or low card. Alice sees it and either bets or checks. Bob does *not* see the card — his two nodes go into one information set — and either calls or folds." + "Here is a miniature poker game. Nature deals Alice a high or low card. Alice sees it and either bets or checks. Bob does *not* see the card, meaning his two nodes go into one information set, and either calls or folds." ] }, { @@ -584,7 +601,7 @@ "id": "56e531a8", "metadata": {}, "source": [ - "Alice knows her card and Bob does not, so this is a game of incomplete information — and its equilibrium involves bluffing. Gambit computes it, and because we ask for exact output, Sage reports the answer in rationals rather than decimals." + "Alice knows her card and Bob does not, so this is a game of incomplete information whose equilibrium involves bluffing and can be computed with Gambit." ] }, { @@ -668,7 +685,7 @@ "source": [ "## Moving games between Sage and Gambit\n", "\n", - "An `ExtensiveFormGame` can also wrap a tree game you already built with PyGambit. The wrapper does not copy anything — `_gambit_` hands back the very same object, so the two views stay in sync." + "An `ExtensiveFormGame` can also wrap a tree game you already built with PyGambit. `_gambit_` hands back the very same object, so the two views stay in sync." ] }, { @@ -826,7 +843,11 @@ "cell_type": "markdown", "id": "a3fc7265", "metadata": {}, - "source": "Both are Nash equilibria, but only one of them survives if you insist that every player behave optimally at every information set they might reach.\n\nThe usual tool for ruling out the other one is subgame perfection, and here it is no help at all: only the root begins a subgame, so the game has no *proper* subgames to refine away anything. That is exactly why Selten introduced this example." + "source": [ + "Both are Nash equilibria, but only one of them survives if you insist that every player behave optimally at every information set they might reach.\n", + "\n", + "The usual tool for ruling out the other one is subgame perfection, and here it is no help at all: only the root begins a subgame, so the game has no *proper* subgames to refine away anything. That is exactly why Selten introduced this example." + ] }, { "cell_type": "code", @@ -865,7 +886,7 @@ "source": [ "## Case study: the absent-minded driver\n", "\n", - "Every solver in Gambit assumes **perfect recall**. When a game violates that assumption, Gambit will not compute equilibria for it — and it is right not to, because the standard theory does not apply.\n", + "Every solver in Gambit assumes **perfect recall**. When a game violates that assumption, Gambit will not compute equilibria for it, because the standard theory does not apply.\n", "\n", "The best known such game is Piccione and Rubinstein's absent-minded driver. A driver must take the second of two identical exits. The two junctions look exactly the same, so they lie in one information set, and at each the driver either continues or exits. Since he cannot tell them apart, he cannot condition on which one he is at.\n", "\n", @@ -908,7 +929,7 @@ "id": "b7dfd7d5", "metadata": {}, "source": [ - "One player, one information set, and no perfect recall — so `obtain_nash` is off the table.\n", + "One player, one information set, and no perfect recall, so `obtain_nash` is not applicable.\n", "\n", "What we can still do is hand Gambit a *plan* and ask what it is worth. A plan here is a single number: the probability $p$ of continuing at a junction. Gambit evaluates it exactly." ] @@ -959,7 +980,7 @@ "source": [ "Gambit evaluates one plan at a time. Sage can recover the whole function.\n", "\n", - "The value is a polynomial in $p$ of degree two — the driver passes at most two junctions — so five exact sample points are more than enough to reconstruct it by interpolation over `QQ`. No floating point, no curve fitting." + "The value is a polynomial in $p$ of degree two (the driver passes at most two junctions) so five exact sample points are more than enough to reconstruct it by interpolation over `QQ`." ] }, { @@ -998,7 +1019,7 @@ "id": "5f393739", "metadata": {}, "source": [ - "With the value function in hand, finding the best plan is calculus, which is exactly what Sage is for." + "With the value function, finding the best plan is calculus, which we can do with Sage." ] }, { @@ -1067,9 +1088,9 @@ "id": "f1b81467", "metadata": {}, "source": [ - "So the driver's best plan is to continue with probability $2/3$, worth $4/3$ — both exact.\n", + "So the driver's best plan is to continue with probability $2/3$, worth $4/3$.\n", "\n", - "The interesting part is the comparison with $p = 1/3$, the probability at which the driver, reasoning at a junction about what to do *now*, is indifferent between continuing and exiting. That plan is worth only $1$. Planning ahead and reasoning in the moment give genuinely different answers, which is the whole point of the example." + "The interesting part is the comparison with $p = 1/3$, the probability at which the driver, reasoning at a junction about what to do *now*, is indifferent between continuing and exiting. That plan is worth only $1$. Planning ahead and reasoning in the moment give different answers." ] }, { @@ -1115,7 +1136,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "Graphics object consisting of 3 graphics primitives" ] @@ -1139,7 +1160,7 @@ "source": [ "The red point is the optimal plan, the green one the point of indifference at a junction.\n", "\n", - "Gambit evaluated the plans; Sage found the function behind them and optimised it. Neither step works without the other.\n", + "Gambit evaluated the plans, whereas Sage found the function behind them and optimised it, playing into each other nicely.\n", "\n", "## Summary\n", "\n", @@ -1168,7 +1189,7 @@ ], "metadata": { "kernelspec": { - "display_name": "SageMath", + "display_name": "SageMath 10.10.beta6", "language": "sage", "name": "sagemath" }, diff --git a/doc/tutorials/interoperability_tutorials/sagemath_normal_form.ipynb b/doc/tutorials/interoperability_tutorials/sagemath_normal_form.ipynb index 9fbbefa63..4b50ff86c 100644 --- a/doc/tutorials/interoperability_tutorials/sagemath_normal_form.ipynb +++ b/doc/tutorials/interoperability_tutorials/sagemath_normal_form.ipynb @@ -144,8 +144,7 @@ "id": "d69f3883", "metadata": {}, "source": [ - "Notice what happened to the numbers.\n", - "Gambit stores payoffs either as exact rationals or as decimals, and Sage keeps that distinction: the integer payoffs above came back as elements of `QQ`, the field of rational numbers, and *not* as floating point approximations." + "Gambit stores payoffs either as exact rationals or as decimals, and Sage keeps this distinction. The integer payoffs above came back as elements of `QQ`, which is the field of rational numbers, and *not* as floating point approximations." ] }, { @@ -181,7 +180,7 @@ "id": "4693f7cf", "metadata": {}, "source": [ - "That matters for everything downstream. `payoff_matrices` hands us the two payoff matrices as genuine Sage matrices over `QQ`, which we can then do linear algebra on." + "That matters for all downstream applications. `payoff_matrices` returns the two payoff matrices as Sage matrices over `QQ`, which we can then do linear algebra on." ] }, { @@ -223,13 +222,14 @@ "source": [ "## From a Sage game to a Gambit game\n", "\n", - "The other direction is the `_gambit_` method, which every Sage object that knows how to talk to Gambit provides.\n", - "It returns a `pygambit.Game`, so the whole Gambit API is available from there — including writing the game out in Gambit's own strategic form format." + "The other direction is the `_gambit_` method, which every Sage NormalFormGame provides.\n", + "It returns a `pygambit.Game`, so the whole Gambit API is available from there, including writing the game out in Gambit's own strategic form format.\n", + "To test this out, we will load the Prinsoner's Dilemma directly from the SageMath strategic game catalog." ] }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 26, "id": "5e49d4cf", "metadata": { "execution": { @@ -252,10 +252,10 @@ "\"\"\n", "\n", "{\n", - "{ \"\" 3.0, 3.0 }\n", - "{ \"\" 5.0, 0.0 }\n", - "{ \"\" 0.0, 5.0 }\n", - "{ \"\" 1.0, 1.0 }\n", + "{ \"\" -2.0, -2.0 }\n", + "{ \"\" 0.0, -5.0 }\n", + "{ \"\" -5.0, 0.0 }\n", + "{ \"\" -4.0, -4.0 }\n", "}\n", "1 2 3 4 \n", "\n" @@ -263,6 +263,7 @@ } ], "source": [ + "pd = game_theory.normal_form_games.PrisonersDilemma()\n", "print(pd._gambit_().to_nfg())" ] }, @@ -279,7 +280,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 9, "id": "fecfdf0f", "metadata": { "execution": { @@ -293,10 +294,10 @@ { "data": { "text/plain": [ - "[3.0, 3, -3.0]" + "[-2.0, -2, 2.0]" ] }, - "execution_count": 7, + "execution_count": 9, "metadata": {}, "output_type": "execute_result" } @@ -324,7 +325,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 10, "id": "537d16f8", "metadata": { "execution": { @@ -338,10 +339,13 @@ { "data": { "text/plain": [ - "Normal Form Game with the following utilities: {(0, 0): [3.0, 3.0], (0, 1): [0.0, 5.0], (1, 0): [5.0, 0.0], (1, 1): [1.0, 1.0]}" + "Normal Form Game with the following utilities: {(0, 0): [-2.0, -2.0],\n", + " (0, 1): [-5.0, 0.0],\n", + " (1, 0): [0.0, -5.0],\n", + " (1, 1): [-4.0, -4.0]}" ] }, - "execution_count": 8, + "execution_count": 10, "metadata": {}, "output_type": "execute_result" } @@ -361,12 +365,12 @@ "metadata": {}, "source": [ "One caveat: a `.nfg` file records payoffs as decimals, so a round trip through disk turns exact rationals into floating point numbers.\n", - "If you care about exactness, keep the Sage object and convert on demand rather than saving and reloading." + "If exactness is important, you should keep the Sage object and convert on demand rather than saving and reloading." ] }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 11, "id": "74dbb8a2", "metadata": { "execution": { @@ -383,7 +387,7 @@ "" ] }, - "execution_count": 9, + "execution_count": 11, "metadata": {}, "output_type": "execute_result" } @@ -399,13 +403,13 @@ "source": [ "## The Gambit game catalog\n", "\n", - "Gambit ships a catalog of games from the research literature, and Sage can pull any of them in.\n", + "As SageMath's catalog of normal form games consists of mostly simpler, common games, we extend it by Gambit's catalog. It allows Sage to access a variety of games from the research literature.\n", "Called with no arguments, `load_from_gambit_catalog` returns a table of what is available." ] }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 12, "id": "1f4c31df", "metadata": { "execution": { @@ -718,7 +722,7 @@ "37 Fig 3 from 'A Note on the Lemke-Howson Algorit... " ] }, - "execution_count": 10, + "execution_count": 12, "metadata": {}, "output_type": "execute_result" } @@ -739,7 +743,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 13, "id": "e871f78c", "metadata": { "execution": { @@ -763,7 +767,7 @@ " (1, 3): [4, 4]}" ] }, - "execution_count": 11, + "execution_count": 13, "metadata": {}, "output_type": "execute_result" } @@ -782,14 +786,14 @@ "## Solving games\n", "\n", "`obtain_nash` is Sage's entry point to equilibrium computation.\n", - "Without an algorithm it picks a sensible default; with one, it dispatches either to Sage's own exact routines or to one of Gambit's solvers.\n", + "Without a passed parameter of which algorithm to use, it picks a sensible default; with the specification of algorithm, it dispatches either to Sage's own exact routines or to one of Gambit's solvers.\n", "\n", "Our test case is the Battle of the Sexes, which has two pure equilibria and one mixed one." ] }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 14, "id": "72d366ce", "metadata": { "execution": { @@ -806,7 +810,7 @@ "[[(0, 1), (0, 1)], [(3/4, 1/4), (1/4, 3/4)], [(1, 0), (1, 0)]]" ] }, - "execution_count": 12, + "execution_count": 14, "metadata": {}, "output_type": "execute_result" } @@ -822,7 +826,7 @@ "id": "6b5ce8a5", "metadata": {}, "source": [ - "The default answer is *exact*: the mixed equilibrium comes out as `3/4` and `1/2`, not as decimals.\n", + "The default answer is *exact*: the mixed equilibrium comes out as `3/4` and `1/4`, not as decimals.\n", "That is Sage's own vertex enumeration at work.\n", "\n", "Handing the same game to Gambit's solvers gives the same equilibria as floating point approximations.\n", @@ -832,7 +836,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 15, "id": "818b0d19", "metadata": { "execution": { @@ -870,7 +874,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 16, "id": "17c23058", "metadata": { "execution": { @@ -887,7 +891,7 @@ "False" ] }, - "execution_count": 14, + "execution_count": 16, "metadata": {}, "output_type": "execute_result" } @@ -911,7 +915,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 17, "id": "908a8a1a", "metadata": { "execution": { @@ -928,7 +932,7 @@ "[[(0.0, 1.0), (0.0, 1.0), (0.0, 1.0)], [(1.0, 0.0), (1.0, 0.0), (1.0, 0.0)]]" ] }, - "execution_count": 15, + "execution_count": 17, "metadata": {}, "output_type": "execute_result" } @@ -949,13 +953,13 @@ "source": [ "Both \"everyone picks the first option\" and \"everyone picks the second\" are equilibria, as expected.\n", "\n", - "This is where Gambit really earns its place: Sage's own solvers only handle two players, so every algorithm for larger games — `'gnm'`, `'enumpure'`, `'enumpoly'`, `'liap'`, `'simpdiv'`, `'ipa'` and `'logit'` — is Gambit's.\n", + "Since Sage's own solvers only handle two players, every algorithm for larger games, comes from the Gambit solver integration. These are: `'gnm'`, `'enumpure'`, `'enumpoly'`, `'liap'`, `'simpdiv'`, `'ipa'` and `'logit'`.\n", "The default for a game with more than two players is `'enumpoly'`, which finds the mixed equilibrium too." ] }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 18, "id": "828a2894", "metadata": { "execution": { @@ -974,7 +978,7 @@ " [(1.0, 0.0), (1.0, 0.0), (1.0, 0.0)]]" ] }, - "execution_count": 16, + "execution_count": 18, "metadata": {}, "output_type": "execute_result" } @@ -995,7 +999,7 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 19, "id": "15895aa1", "metadata": { "execution": { @@ -1013,7 +1017,7 @@ "Graphics object consisting of 28 graphics primitives" ] }, - "execution_count": 17, + "execution_count": 19, "metadata": {}, "output_type": "execute_result" } @@ -1031,16 +1035,16 @@ "source": [ "## Case study 1: a game whose payoffs are symbols\n", "\n", - "Everything so far could be described as file conversion. This is where the integration starts to pay for itself.\n", + "So far the tutorial mostly showcased object conversion between the two libraries. Now it gets more interesting.\n", "\n", - "Gambit's solvers work on numbers. Sage's symbolic ring works on *expressions*, and a `NormalFormGame` is perfectly happy to hold them. So we can write down a whole family of games at once and solve it in closed form.\n", + "While Gambit's solvers work on numbers, Sage's symbolic ring works on *expressions*. So we can write down a whole family of games at once by using a `NormalFormGame` which contains expressions instead of explicit numbers and solve it in closed form.\n", "\n", "The example is Hawk–Dove. Two animals contest a resource worth $v$. Two doves split it; a hawk takes it from a dove; two hawks fight and share the value minus a cost $c$ of injury." ] }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 20, "id": "d041d5a4", "metadata": { "execution": { @@ -1060,7 +1064,7 @@ " (1, 1): [1/2*v, 1/2*v]}" ] }, - "execution_count": 18, + "execution_count": 20, "metadata": {}, "output_type": "execute_result" } @@ -1085,7 +1089,7 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 21, "id": "984ad51b", "metadata": { "execution": { @@ -1102,7 +1106,7 @@ "[p == v/c]" ] }, - "execution_count": 19, + "execution_count": 21, "metadata": {}, "output_type": "execute_result" } @@ -1120,13 +1124,13 @@ "id": "76ef7676", "metadata": {}, "source": [ - "The equilibrium share of hawks is $p^* = v/c$ — a closed form valid for every $v$ and $c$ at once, which no numerical solver could have produced.\n", + "The equilibrium share of hawks is $p^* = v/c$. This is a closed form valid for every $v$ and $c$ at once, which no numerical solver could have produced.\n", "Being an ordinary Sage expression, we can now plot it, differentiate it, or take limits of it." ] }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 22, "id": "503b6b13", "metadata": { "execution": { @@ -1139,12 +1143,12 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "Graphics object consisting of 1 graphics primitive" ] }, - "execution_count": 20, + "execution_count": 22, "metadata": {}, "output_type": "execute_result" } @@ -1167,7 +1171,7 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 24, "id": "5b711f6b", "metadata": { "execution": { @@ -1187,7 +1191,7 @@ " [(1.0, 0.0), (0.0, 1.0)]]" ] }, - "execution_count": 21, + "execution_count": 24, "metadata": {}, "output_type": "execute_result" } @@ -1208,7 +1212,7 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 23, "id": "40eff1c4", "metadata": { "execution": { @@ -1225,7 +1229,7 @@ "2/5" ] }, - "execution_count": 22, + "execution_count": 23, "metadata": {}, "output_type": "execute_result" } @@ -1243,14 +1247,14 @@ "\n", "The second thing Sage brings is its library of mathematical objects. Here we turn a *graph* into a game and let Gambit analyse it.\n", "\n", - "In the **max cut game**, every vertex of a graph is a player choosing one of two sides. A player's payoff is the number of its incident edges that end up cut, that is, joining vertices on opposite sides. A pure Nash equilibrium is exactly a cut that no single vertex can improve by switching sides — a *locally* optimal cut.\n", + "In the **max cut game**, every vertex of a graph is a player choosing one of two sides. A player's actions are either `0` or `1`, representing the side they choose, and the payoff is the number of its incident edges that end up cut, that is, joining vertices on opposite sides. A pure Nash equilibrium is exactly a cut that no single vertex can improve by switching sides, thus a *locally* optimal cut.\n", "\n", "We use the house graph: five vertices, six edges." ] }, { "cell_type": "code", - "execution_count": 23, + "execution_count": 27, "id": "00206d88", "metadata": { "execution": { @@ -1268,7 +1272,7 @@ "Graphics object consisting of 12 graphics primitives" ] }, - "execution_count": 23, + "execution_count": 27, "metadata": {}, "output_type": "execute_result" } @@ -1289,7 +1293,7 @@ }, { "cell_type": "code", - "execution_count": 24, + "execution_count": 30, "id": "81e592cd", "metadata": { "execution": { @@ -1306,7 +1310,7 @@ "5" ] }, - "execution_count": 24, + "execution_count": 30, "metadata": {}, "output_type": "execute_result" } @@ -1333,12 +1337,12 @@ "id": "a360b077", "metadata": {}, "source": [ - "Five players, so this is squarely in Gambit's territory. `'enumpure'` enumerates the pure equilibria." + "For five players, we use Gambit's `'enumpure'` to enumerate the pure equilibria." ] }, { "cell_type": "code", - "execution_count": 25, + "execution_count": 31, "id": "0ec6a91b", "metadata": { "execution": { @@ -1355,7 +1359,7 @@ "6" ] }, - "execution_count": 25, + "execution_count": 31, "metadata": {}, "output_type": "execute_result" } @@ -1370,12 +1374,12 @@ "id": "638113c9", "metadata": {}, "source": [ - "Now we read each equilibrium back as a cut and measure it — and here Sage answers a question Gambit cannot even be asked, by computing the true maximum cut exactly." + "Each equilibrium is a cut, so we read the profiles back and count how many edges each one cuts." ] }, { "cell_type": "code", - "execution_count": 26, + "execution_count": 34, "id": "cddb87cf", "metadata": { "execution": { @@ -1387,57 +1391,16 @@ }, "outputs": [ { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "
equilibriumedges cut
\\(\\left(0, 0, 1, 1, 0\\right)\\)\\(4\\)
\\(\\left(0, 1, 1, 0, 0\\right)\\)\\(5\\)
\\(\\left(0, 1, 1, 0, 1\\right)\\)\\(5\\)
\\(\\left(1, 0, 0, 1, 0\\right)\\)\\(5\\)
\\(\\left(1, 0, 0, 1, 1\\right)\\)\\(5\\)
\\(\\left(1, 1, 0, 0, 1\\right)\\)\\(4\\)
\n", - "
" - ], - "text/plain": [ - " equilibrium edges cut\n", - "├─────────────────┼───────────┤\n", - " (0, 0, 1, 1, 0) 4\n", - " (0, 1, 1, 0, 0) 5\n", - " (0, 1, 1, 0, 1) 5\n", - " (1, 0, 0, 1, 0) 5\n", - " (1, 0, 0, 1, 1) 5\n", - " (1, 1, 0, 0, 1) 4" - ] - }, - "execution_count": 26, - "metadata": {}, - "output_type": "execute_result" + "name": "stdout", + "output_type": "stream", + "text": [ + "(0, 0, 1, 1, 0) cuts 4 edges\n", + "(0, 1, 1, 0, 0) cuts 5 edges\n", + "(0, 1, 1, 0, 1) cuts 5 edges\n", + "(1, 0, 0, 1, 0) cuts 5 edges\n", + "(1, 0, 0, 1, 1) cuts 5 edges\n", + "(1, 1, 0, 0, 1) cuts 4 edges\n" + ] } ], "source": [ @@ -1446,8 +1409,8 @@ "\n", "\n", "profiles = sorted({tuple(int(round(s[1])) for s in eq) for eq in equilibria})\n", - "table([(profile, cut_size(profile)) for profile in profiles],\n", - " header_row=[\"equilibrium\", \"edges cut\"])" + "for profile in profiles:\n", + " print(f\"{profile} cuts {cut_size(profile)} edges\")" ] }, { @@ -1486,7 +1449,7 @@ "Four of the six equilibria achieve the optimum of five cut edges, but two of them get stuck at four.\n", "Those are the locally stable cuts that are not globally optimal, and the ratio $4/5$ is this game's price of anarchy.\n", "\n", - "Gambit found the equilibria; Sage certified which of them were actually good. Neither library could have produced that sentence alone.\n", + "Gambit found the equilibria, whereas with Sage we could certify which of them were actually the global maximum, demonstrsting the symbiosis between the two libraries.\n", "\n", "## Summary\n", "\n", @@ -1508,11 +1471,17 @@ "- [SageMath game theory reference](https://doc.sagemath.org/html/en/reference/game_theory/index.html)\n", "- [PyGambit API documentation](https://gambitproject.readthedocs.io/en/latest/pygambit.api.html)" ] + }, + { + "cell_type": "markdown", + "id": "3e04602e", + "metadata": {}, + "source": [] } ], "metadata": { "kernelspec": { - "display_name": "SageMath", + "display_name": "SageMath 10.10.beta6", "language": "sage", "name": "sagemath" }, From 810ebd3cd63cb495c74687316cf83ef4997d0099 Mon Sep 17 00:00:00 2001 From: Amelie Kleber Date: Sun, 23 Aug 2026 19:37:13 +0200 Subject: [PATCH 3/3] adjust tutorials to integration changes (exactness and class methods) --- .../sagemath_extensive_form.ipynb | 874 ++++++++++++------ .../sagemath_normal_form.ipynb | 694 +++++++++----- 2 files changed, 1027 insertions(+), 541 deletions(-) diff --git a/doc/tutorials/interoperability_tutorials/sagemath_extensive_form.ipynb b/doc/tutorials/interoperability_tutorials/sagemath_extensive_form.ipynb index d25ea1854..cd6cdf764 100644 --- a/doc/tutorials/interoperability_tutorials/sagemath_extensive_form.ipynb +++ b/doc/tutorials/interoperability_tutorials/sagemath_extensive_form.ipynb @@ -25,10 +25,10 @@ "id": "1024561a", "metadata": { "execution": { - "iopub.execute_input": "2026-08-18T22:21:58.846162Z", - "iopub.status.busy": "2026-08-18T22:21:58.845877Z", - "iopub.status.idle": "2026-08-18T22:22:00.295244Z", - "shell.execute_reply": "2026-08-18T22:22:00.294822Z" + "iopub.execute_input": "2026-08-23T17:16:29.873621Z", + "iopub.status.busy": "2026-08-23T17:16:29.873430Z", + "iopub.status.idle": "2026-08-23T17:16:32.679478Z", + "shell.execute_reply": "2026-08-23T17:16:32.678550Z" } }, "outputs": [], @@ -47,7 +47,7 @@ "\n", "We build the Battle of the Sexes as a sequential game: Amy chooses first, Bob sees what she chose and responds.\n", "\n", - "Two things are worth knowing before we start. A node is identified by the path of action labels leading to it, so `root.children['game']` is the node reached when Amy plays `game`. And an outcome is attached with `set_outcome`, which takes a label and the list of payoffs." + "Two things are worth knowing before we start. A node is identified by the path of action labels leading to it, so `root.children['game']` is the node reached when Amy plays `game`. And an outcome is attached with `set_outcome`, which takes a label for the new outcome and the list of payoffs it awards." ] }, { @@ -56,10 +56,10 @@ "id": "ae2f549a", "metadata": { "execution": { - "iopub.execute_input": "2026-08-18T22:22:00.296450Z", - "iopub.status.busy": "2026-08-18T22:22:00.296335Z", - "iopub.status.idle": "2026-08-18T22:22:00.304715Z", - "shell.execute_reply": "2026-08-18T22:22:00.304304Z" + "iopub.execute_input": "2026-08-23T17:16:32.681727Z", + "iopub.status.busy": "2026-08-23T17:16:32.681418Z", + "iopub.status.idle": "2026-08-23T17:16:32.698583Z", + "shell.execute_reply": "2026-08-23T17:16:32.697847Z" } }, "outputs": [ @@ -96,7 +96,7 @@ "id": "15e1547c", "metadata": {}, "source": [ - "Because Bob observes Amy's choice, he is at a different decision point in each branch. That gives three information sets, one for Amy and one for each of Bob's two nodes, each containing a single node." + "Because Bob observes Amy's choice, he is at a different decision point in each branch. That gives three information sets — one for Amy and one for each of Bob's two nodes — each containing a single node." ] }, { @@ -105,10 +105,10 @@ "id": "933a455b", "metadata": { "execution": { - "iopub.execute_input": "2026-08-18T22:22:00.305660Z", - "iopub.status.busy": "2026-08-18T22:22:00.305567Z", - "iopub.status.idle": "2026-08-18T22:22:00.307923Z", - "shell.execute_reply": "2026-08-18T22:22:00.307603Z" + "iopub.execute_input": "2026-08-23T17:16:32.700367Z", + "iopub.status.busy": "2026-08-23T17:16:32.700175Z", + "iopub.status.idle": "2026-08-23T17:16:32.703897Z", + "shell.execute_reply": "2026-08-23T17:16:32.703235Z" } }, "outputs": [ @@ -132,9 +132,8 @@ "id": "68fb2823", "metadata": {}, "source": [ - "## Drawing the tree\n", - "\n", - "`plot` draws the tree. You can choose to use Sage's own graphics, so it works anywhere Sage does. Because Bob's two decision nodes are in two different infosets, they are numbered based on which infoset they belong to." + "The `players`, `infosets`, `outcomes` and `root` properties expose the underlying Gambit objects, so anything the Gambit API can do with them is available.\n", + "`to_efg` returns the whole tree as a string in Gambit's extensive form format, which is a convenient way to see the structure that the short representation above hides." ] }, { @@ -143,10 +142,55 @@ "id": "469abff9", "metadata": { "execution": { - "iopub.execute_input": "2026-08-18T22:22:00.308784Z", - "iopub.status.busy": "2026-08-18T22:22:00.308710Z", - "iopub.status.idle": "2026-08-18T22:22:00.591180Z", - "shell.execute_reply": "2026-08-18T22:22:00.590770Z" + "iopub.execute_input": "2026-08-23T17:16:32.705240Z", + "iopub.status.busy": "2026-08-23T17:16:32.705084Z", + "iopub.status.idle": "2026-08-23T17:16:32.707808Z", + "shell.execute_reply": "2026-08-23T17:16:32.707100Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "EFG 2 R \"Untitled extensive game\" { \"Amy\" \"Bob\" }\n", + "\"\"\n", + "\n", + "p \"\" 1 1 \"\" { \"game\" \"movie\" } 0\n", + "p \"\" 2 1 \"\" { \"game\" \"movie\" } 0\n", + "t \"\" 1 \"game,game\" { 3, 2 }\n", + "t \"\" 2 \"game,movie\" { 1, 1 }\n", + "p \"\" 2 2 \"\" { \"game\" \"movie\" } 0\n", + "t \"\" 3 \"movie,game\" { 0, 0 }\n", + "t \"\" 4 \"movie,movie\" { 2, 3 }\n", + "\n" + ] + } + ], + "source": [ + "print(battle.to_efg())" + ] + }, + { + "cell_type": "markdown", + "id": "28ec7be8", + "metadata": {}, + "source": [ + "## Drawing the tree\n", + "\n", + "`plot` draws the tree. The default backend uses Sage's own graphics, so it works anywhere Sage does." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "22a8dabc", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-23T17:16:32.709265Z", + "iopub.status.busy": "2026-08-23T17:16:32.709111Z", + "iopub.status.idle": "2026-08-23T17:16:33.266198Z", + "shell.execute_reply": "2026-08-23T17:16:33.265578Z" } }, "outputs": [ @@ -157,7 +201,7 @@ "Graphics object consisting of 20 graphics primitives" ] }, - "execution_count": 4, + "execution_count": 5, "metadata": {}, "output_type": "execute_result" } @@ -168,22 +212,23 @@ }, { "cell_type": "markdown", - "id": "28ec7be8", + "id": "c29ffa88", "metadata": {}, "source": [ - "The `'gtdraw'` backend instead produces a TikZ picture, which is what you want for a paper: it is vector output with real LaTeX typesetting. It returns a picture object that can be rendered to PDF, SVG or PNG, or whose LaTeX source you can paste into a document." + "The `'gtdraw'` backend instead produces a TikZ picture, which is what you want for a paper: it is vector output with real LaTeX typesetting. It returns a picture object whose LaTeX source you can paste into a document, and which can also be rendered to PDF, SVG or PNG.\n", + "Rendering compiles the source, so it needs a LaTeX installation on the kernel's `PATH` (`pdflatex`), plus `pdftocairo` from poppler for SVG and PNG. The cell below checks for both and skips the rendering if they are missing; `picture.content()` is the full source either way." ] }, { "cell_type": "code", - "execution_count": 5, - "id": "22a8dabc", + "execution_count": 6, + "id": "2df55a18", "metadata": { "execution": { - "iopub.execute_input": "2026-08-18T22:22:00.592358Z", - "iopub.status.busy": "2026-08-18T22:22:00.592235Z", - "iopub.status.idle": "2026-08-18T22:22:00.600318Z", - "shell.execute_reply": "2026-08-18T22:22:00.599927Z" + "iopub.execute_input": "2026-08-23T17:16:33.267589Z", + "iopub.status.busy": "2026-08-23T17:16:33.267366Z", + "iopub.status.idle": "2026-08-23T17:16:33.281307Z", + "shell.execute_reply": "2026-08-23T17:16:33.280686Z" } }, "outputs": [ @@ -207,21 +252,21 @@ }, { "cell_type": "code", - "execution_count": 6, - "id": "c29ffa88", + "execution_count": 7, + "id": "1dde74fc", "metadata": { "execution": { - "iopub.execute_input": "2026-08-18T22:22:00.601237Z", - "iopub.status.busy": "2026-08-18T22:22:00.601155Z", - "iopub.status.idle": "2026-08-18T22:22:01.665252Z", - "shell.execute_reply": "2026-08-18T22:22:01.664825Z" + "iopub.execute_input": "2026-08-23T17:16:33.282632Z", + "iopub.status.busy": "2026-08-23T17:16:33.282468Z", + "iopub.status.idle": "2026-08-23T17:16:35.220399Z", + "shell.execute_reply": "2026-08-23T17:16:35.219647Z" } }, "outputs": [ { "data": { "image/svg+xml": [ - "\n", + "\n", "\n", "\n", "\n", @@ -258,120 +303,120 @@ "\n", "\n", "\n", - "\n", + "\n", "\n", "\n", - "\n", + "\n", "\n", "\n", - "\n", + "\n", "\n", "\n", - "\n", + "\n", "\n", "\n", "\n", "\n", - "\n", - "\n", + "\n", + "\n", "\n", "\n", - "\n", + "\n", "\n", - "\n", + "\n", "\n", - "\n", - "\n", - "\n", + "\n", + "\n", + "\n", "\n", "\n", - "\n", + "\n", "\n", "\n", - "\n", - "\n", - "\n", + "\n", + "\n", + "\n", "\n", - "\n", + "\n", "\n", - "\n", + "\n", "\n", "\n", - "\n", + "\n", "\n", "\n", - "\n", + "\n", "\n", "\n", - "\n", - "\n", - "\n", + "\n", + "\n", + "\n", "\n", - "\n", + "\n", "\n", - "\n", + "\n", "\n", "\n", - "\n", + "\n", "\n", "\n", - "\n", - "\n", + "\n", + "\n", "\n", "\n", - "\n", - "\n", - "\n", + "\n", + "\n", + "\n", "\n", - "\n", + "\n", "\n", - "\n", - "\n", - "\n", + "\n", + "\n", + "\n", "\n", "\n", - "\n", - "\n", + "\n", + "\n", "\n", "\n", - "\n", - "\n", - "\n", + "\n", + "\n", + "\n", "\n", - "\n", + "\n", "\n", - "\n", + "\n", "\n", "\n", - "\n", + "\n", "\n", "\n", - "\n", + "\n", "\n", "\n", - "\n", - "\n", - "\n", + "\n", + "\n", + "\n", "\n", - "\n", + "\n", "\n", - "\n", + "\n", "\n", "\n", - "\n", + "\n", "\n", "\n", - "\n", - "\n", + "\n", + "\n", "\n", "\n", - "\n", - "\n", - "\n", + "\n", + "\n", + "\n", "\n", - "\n", - "\n", - "\n", + "\n", + "\n", + "\n", "" ], "text/plain": [ @@ -395,7 +440,7 @@ }, { "cell_type": "markdown", - "id": "2df55a18", + "id": "7ba40bdc", "metadata": {}, "source": [ "## Information sets\n", @@ -407,14 +452,14 @@ }, { "cell_type": "code", - "execution_count": 7, - "id": "1dde74fc", + "execution_count": 8, + "id": "6e0e6e2d", "metadata": { "execution": { - "iopub.execute_input": "2026-08-18T22:22:01.666620Z", - "iopub.status.busy": "2026-08-18T22:22:01.666513Z", - "iopub.status.idle": "2026-08-18T22:22:01.669767Z", - "shell.execute_reply": "2026-08-18T22:22:01.669322Z" + "iopub.execute_input": "2026-08-23T17:16:35.222053Z", + "iopub.status.busy": "2026-08-23T17:16:35.221853Z", + "iopub.status.idle": "2026-08-23T17:16:35.227479Z", + "shell.execute_reply": "2026-08-23T17:16:35.226831Z" } }, "outputs": [ @@ -424,7 +469,7 @@ "(2, [1, 2])" ] }, - "execution_count": 7, + "execution_count": 8, "metadata": {}, "output_type": "execute_result" } @@ -447,22 +492,22 @@ }, { "cell_type": "markdown", - "id": "7ba40bdc", + "id": "abc8a31e", "metadata": {}, "source": [ - "Two information sets now, one of which contains two nodes. Sage can also confirm that the game has perfect recall, meaning no player ever forgets something they previously knew which is an assumption every one of Gambit's solvers relies on." + "Two information sets now, one of which contains two nodes. Sage can also confirm that the game has perfect recall, meaning no player ever forgets something they previously knew — an assumption every one of Gambit's solvers relies on." ] }, { "cell_type": "code", - "execution_count": 8, - "id": "6e0e6e2d", + "execution_count": 9, + "id": "97932afe", "metadata": { "execution": { - "iopub.execute_input": "2026-08-18T22:22:01.670732Z", - "iopub.status.busy": "2026-08-18T22:22:01.670629Z", - "iopub.status.idle": "2026-08-18T22:22:01.672787Z", - "shell.execute_reply": "2026-08-18T22:22:01.672417Z" + "iopub.execute_input": "2026-08-23T17:16:35.228945Z", + "iopub.status.busy": "2026-08-23T17:16:35.228763Z", + "iopub.status.idle": "2026-08-23T17:16:35.231957Z", + "shell.execute_reply": "2026-08-23T17:16:35.231358Z" } }, "outputs": [ @@ -472,7 +517,7 @@ "True" ] }, - "execution_count": 8, + "execution_count": 9, "metadata": {}, "output_type": "execute_result" } @@ -483,23 +528,23 @@ }, { "cell_type": "markdown", - "id": "abc8a31e", + "id": "839852c9", "metadata": {}, "source": [ "That single change to the information structure changes the answer.\n", - "`obtain_nash` sends the game to a Gambit solver and hands back equilibria as behaviour profiles; we read off what each is worth to each player, exactly, with `QQ`." + "`obtain_nash` sends the game to a Gambit solver and hands back one profile per equilibrium; we read off what each is worth to each player, exactly, with `QQ`." ] }, { "cell_type": "code", - "execution_count": 9, - "id": "97932afe", + "execution_count": 10, + "id": "dc5db809", "metadata": { "execution": { - "iopub.execute_input": "2026-08-18T22:22:01.673624Z", - "iopub.status.busy": "2026-08-18T22:22:01.673545Z", - "iopub.status.idle": "2026-08-18T22:22:01.677339Z", - "shell.execute_reply": "2026-08-18T22:22:01.677062Z" + "iopub.execute_input": "2026-08-23T17:16:35.233295Z", + "iopub.status.busy": "2026-08-23T17:16:35.233157Z", + "iopub.status.idle": "2026-08-23T17:16:35.275705Z", + "shell.execute_reply": "2026-08-23T17:16:35.275246Z" } }, "outputs": [ @@ -526,7 +571,7 @@ }, { "cell_type": "markdown", - "id": "839852c9", + "id": "035299df", "metadata": {}, "source": [ "When Bob moves second he can condition on Amy's choice, and there are three pure equilibria (two of which end at the same outcome). When the players move simultaneously, only two survive." @@ -534,44 +579,128 @@ }, { "cell_type": "markdown", - "id": "dc5db809", + "id": "56e531a8", + "metadata": {}, + "source": [ + "### Behaviour and mixed strategy profiles\n", + "\n", + "By default the solvers work directly on the tree, and an equilibrium comes back as a **behavior profile**: it gives, for every action, the probability of playing it *conditional on reaching that information set*. Index it by an action, an information set or a player.\n", + "\n", + "Passing `use_strategic=True` solves the reduced strategic form instead, and an equilibrium comes back as a **mixed strategy profile** over complete contingent plans. The two are indexed differently and are not interchangeable — indexing one the way you would index the other raises a `TypeError`." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "53bf7311", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-23T17:16:35.277323Z", + "iopub.status.busy": "2026-08-23T17:16:35.277144Z", + "iopub.status.idle": "2026-08-23T17:16:35.281137Z", + "shell.execute_reply": "2026-08-23T17:16:35.280515Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "behavior, by action [1, 0, 1, 0, 1, 0]\n", + "mixed, by strategy [1, 0, 0, 0]\n" + ] + } + ], + "source": [ + "behavior = battle.obtain_nash(algorithm=\"enumpure\")[0]\n", + "mixed = battle.obtain_nash(algorithm=\"enumpure\", use_strategic=True)[0]\n", + "\n", + "game = battle._gambit_()\n", + "print(\"behavior, by action \", [QQ(behavior[a]) for a in game.actions])\n", + "print(\"mixed, by strategy \", [QQ(mixed[s]) for s in game.players[\"Bob\"].strategies])" + ] + }, + { + "cell_type": "markdown", + "id": "2b75e1c9", + "metadata": {}, + "source": [ + "The choice of algorithm is separate. `'lcp'` is the default for a game with at most two players and `'enumpoly'` for more; `'lp'` (constant sum, two players), `'enumpure'`, `'logit'` and `'liap'` are also available.\n", + "\n", + "As in the strategic form, `obtain_nash` answers with exact rationals by default. `'lcp'` and `'lp'` are asked to compute exactly throughout, while the numerical solvers compute in floating point and have their answer rounded to the exact equilibrium it approximates, once Gambit has confirmed in exact arithmetic that it is one. `rational=False` returns the raw floating point answer, and `tolerance` controls how far a probability may be moved to be rounded." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "cfe68ddf", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-23T17:16:35.282362Z", + "iopub.status.busy": "2026-08-23T17:16:35.282212Z", + "iopub.status.idle": "2026-08-23T17:16:35.296280Z", + "shell.execute_reply": "2026-08-23T17:16:35.295715Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "rational=True [[1, 0, 1, 0, 0, 1]]\n", + "rational=False [[0.9999999867182776, 1.3281724096823341e-08, 0.999999986718284, 1.3281717697986011e-08, 2.342948554313063e-24, 1.0]]\n" + ] + } + ], + "source": [ + "for rational in [True, False]:\n", + " equilibria = battle.obtain_nash(algorithm=\"logit\", rational=rational)\n", + " print(f\"rational={str(rational):5s}\",\n", + " [[QQ(eq[a]) if rational else eq[a] for a in game.actions]\n", + " for eq in equilibria])" + ] + }, + { + "cell_type": "markdown", + "id": "215c3289", "metadata": {}, "source": [ "## Chance moves\n", "\n", - "Real games often start with a deal, a roll, or some other move by nature. `append_chance_move` adds one, with exact rational probabilities.\n", + "Real games often start with a deal, a roll, or some other move by nature. `append_chance_move` adds one. Its probabilities are optional and default to a uniform distribution over the actions, held exactly; `set_chance_probs` changes them afterwards.\n", + "\n", + "Here is a miniature poker game. Nature deals Alice a high or low card. Alice sees it and either bets or checks. Bob does *not* see the card — his two nodes go into one information set — and either calls or folds.\n", "\n", - "Here is a miniature poker game. Nature deals Alice a high or low card. Alice sees it and either bets or checks. Bob does *not* see the card, meaning his two nodes go into one information set, and either calls or folds." + "Two of the leaves award the same payoffs, namely those where Bob folds. Giving `set_outcome` an outcome the game already has, rather than a label and a fresh list of payoffs, awards that same outcome at another leaf instead of creating a duplicate." ] }, { "cell_type": "code", - "execution_count": 10, - "id": "035299df", + "execution_count": 13, + "id": "8528d0b7", "metadata": { "execution": { - "iopub.execute_input": "2026-08-18T22:22:01.678250Z", - "iopub.status.busy": "2026-08-18T22:22:01.678175Z", - "iopub.status.idle": "2026-08-18T22:22:01.712644Z", - "shell.execute_reply": "2026-08-18T22:22:01.712252Z" + "iopub.execute_input": "2026-08-23T17:16:35.297555Z", + "iopub.status.busy": "2026-08-23T17:16:35.297400Z", + "iopub.status.idle": "2026-08-23T17:16:35.304306Z", + "shell.execute_reply": "2026-08-23T17:16:35.303792Z" } }, "outputs": [ { "data": { - "image/png": "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", "text/plain": [ - "Graphics object consisting of 32 graphics primitives" + "(['1/2', '1/2'], 5)" ] }, - "execution_count": 10, + "execution_count": 13, "metadata": {}, "output_type": "execute_result" } ], "source": [ "poker = ExtensiveFormGame(players=[\"Alice\", \"Bob\"])\n", - "poker.append_chance_move(poker.root, [\"High\", \"Low\"], [1/2, 1/2])\n", + "poker.append_chance_move(poker.root, [\"High\", \"Low\"])\n", "\n", "for card in [\"High\", \"Low\"]:\n", " poker.append_move(poker.root.children[card], \"Alice\", [\"bet\", \"check\"])\n", @@ -581,39 +710,71 @@ "poker.append_infoset(poker.root.children[\"Low\"].children[\"bet\"],\n", " poker.root.children[\"High\"].children[\"bet\"])\n", "\n", - "showdown = {(\"High\", \"bet\", \"call\"): [2, -2], (\"High\", \"bet\", \"fold\"): [1, -1],\n", - " (\"Low\", \"bet\", \"call\"): [-2, 2], (\"Low\", \"bet\", \"fold\"): [1, -1]}\n", - "for (card, action, response), payoff in showdown.items():\n", - " poker.set_outcome(\n", - " poker.root.children[card].children[action].children[response],\n", - " f\"{card},{action},{response}\", payoff)\n", + "poker.set_outcome(poker.root.children[\"High\"].children[\"bet\"].children[\"call\"],\n", + " \"High,bet,call\", [2, -2])\n", + "poker.set_outcome(poker.root.children[\"Low\"].children[\"bet\"].children[\"call\"],\n", + " \"Low,bet,call\", [-2, 2])\n", + "\n", + "poker.set_outcome(poker.root.children[\"High\"].children[\"bet\"].children[\"fold\"],\n", + " \"Bob folds\", [1, -1])\n", + "poker.set_outcome(poker.root.children[\"Low\"].children[\"bet\"].children[\"fold\"],\n", + " \"Bob folds\")\n", "\n", "poker.set_outcome(poker.root.children[\"High\"].children[\"check\"],\n", " \"High,check\", [1, -1])\n", "poker.set_outcome(poker.root.children[\"Low\"].children[\"check\"],\n", " \"Low,check\", [-1, 1])\n", "\n", + "[str(action.prob) for action in poker.root.infoset.actions], len(poker.outcomes)" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "45db887f", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-23T17:16:35.305525Z", + "iopub.status.busy": "2026-08-23T17:16:35.305368Z", + "iopub.status.idle": "2026-08-23T17:16:35.370348Z", + "shell.execute_reply": "2026-08-23T17:16:35.369524Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "Graphics object consisting of 32 graphics primitives" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ "poker.plot(backend=\"sage\")" ] }, { "cell_type": "markdown", - "id": "56e531a8", + "id": "a915228c", "metadata": {}, "source": [ - "Alice knows her card and Bob does not, so this is a game of incomplete information whose equilibrium involves bluffing and can be computed with Gambit." + "Alice knows her card and Bob does not, so this is a game of incomplete information — and its equilibrium involves bluffing. Because the chance probabilities are exact rationals and `'lcp'` computes exactly, the answer is exact too." ] }, { "cell_type": "code", - "execution_count": 11, - "id": "53bf7311", + "execution_count": 15, + "id": "3a1e9237", "metadata": { "execution": { - "iopub.execute_input": "2026-08-18T22:22:01.713604Z", - "iopub.status.busy": "2026-08-18T22:22:01.713520Z", - "iopub.status.idle": "2026-08-18T22:22:01.717115Z", - "shell.execute_reply": "2026-08-18T22:22:01.716807Z" + "iopub.execute_input": "2026-08-23T17:16:35.372103Z", + "iopub.status.busy": "2026-08-23T17:16:35.371890Z", + "iopub.status.idle": "2026-08-23T17:16:35.378735Z", + "shell.execute_reply": "2026-08-23T17:16:35.378015Z" } }, "outputs": [ @@ -625,7 +786,7 @@ " 'Bob calls': 2/3}" ] }, - "execution_count": 11, + "execution_count": 15, "metadata": {}, "output_type": "execute_result" } @@ -644,7 +805,7 @@ }, { "cell_type": "markdown", - "id": "2b75e1c9", + "id": "8eedd88c", "metadata": {}, "source": [ "Alice always bets with a high card, bluffs with a low card exactly one third of the time, and Bob calls two thirds of the time. The game is worth `1/3` to Alice:" @@ -652,14 +813,14 @@ }, { "cell_type": "code", - "execution_count": 12, - "id": "cfe68ddf", + "execution_count": 16, + "id": "c1c7dce7", "metadata": { "execution": { - "iopub.execute_input": "2026-08-18T22:22:01.718071Z", - "iopub.status.busy": "2026-08-18T22:22:01.717992Z", - "iopub.status.idle": "2026-08-18T22:22:01.720344Z", - "shell.execute_reply": "2026-08-18T22:22:01.719939Z" + "iopub.execute_input": "2026-08-23T17:16:35.380622Z", + "iopub.status.busy": "2026-08-23T17:16:35.380428Z", + "iopub.status.idle": "2026-08-23T17:16:35.384606Z", + "shell.execute_reply": "2026-08-23T17:16:35.383622Z" } }, "outputs": [ @@ -669,7 +830,7 @@ "1/3" ] }, - "execution_count": 12, + "execution_count": 16, "metadata": {}, "output_type": "execute_result" } @@ -680,24 +841,80 @@ }, { "cell_type": "markdown", - "id": "215c3289", + "id": "a3fc7265", + "metadata": {}, + "source": [ + "## Editing a tree\n", + "\n", + "A tree does not have to be built strictly from the root down. `insert_move` puts a new move immediately *above* an existing node, pushing the subtree below it down a level, and `delete_tree` removes everything below a node, turning it back into a leaf.\n", + "\n", + "Here Bob gets a chance to walk away before Alice moves at all, and then the branch in which he plays is cut back off." + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "2e2693cc", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-23T17:16:35.386102Z", + "iopub.status.busy": "2026-08-23T17:16:35.385939Z", + "iopub.status.idle": "2026-08-23T17:16:35.391795Z", + "shell.execute_reply": "2026-08-23T17:16:35.390997Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "as built root: Alice ['L', 'R'], 2 leaves\n", + "after insert_move root: Bob ['play', 'walk'], 3 leaves\n", + "after delete_tree root: Bob ['play', 'walk'], 2 leaves\n" + ] + } + ], + "source": [ + "def describe(game, note):\n", + " root = game.root.infoset\n", + " leaves = sum(1 for node in game._gambit_().nodes if node.is_terminal)\n", + " print(f\"{note:18s} root: {root.player.label:5s} \"\n", + " f\"{[action.label for action in root.actions]}, {leaves} leaves\")\n", + "\n", + "\n", + "editable = ExtensiveFormGame(players=[\"Alice\", \"Bob\"])\n", + "editable.append_move(editable.root, \"Alice\", [\"L\", \"R\"])\n", + "editable.set_outcome(editable.root.children[\"L\"], \"L\", [2, 5])\n", + "editable.set_outcome(editable.root.children[\"R\"], \"R\", [3, 1])\n", + "describe(editable, \"as built\")\n", + "\n", + "editable.insert_move(editable.root, \"Bob\", [\"play\", \"walk\"])\n", + "describe(editable, \"after insert_move\")\n", + "\n", + "editable.delete_tree(editable.root.children[\"play\"])\n", + "describe(editable, \"after delete_tree\")" + ] + }, + { + "cell_type": "markdown", + "id": "cdcdca5d", "metadata": {}, "source": [ "## Moving games between Sage and Gambit\n", "\n", - "An `ExtensiveFormGame` can also wrap a tree game you already built with PyGambit. `_gambit_` hands back the very same object, so the two views stay in sync." + "An `ExtensiveFormGame` can also wrap a tree game you already built with PyGambit. The wrapper does not copy anything — `_gambit_` hands back the very same object, so the two views stay in sync." ] }, { "cell_type": "code", - "execution_count": 13, - "id": "8528d0b7", + "execution_count": 18, + "id": "bf14b609", "metadata": { "execution": { - "iopub.execute_input": "2026-08-18T22:22:01.721216Z", - "iopub.status.busy": "2026-08-18T22:22:01.721132Z", - "iopub.status.idle": "2026-08-18T22:22:01.723876Z", - "shell.execute_reply": "2026-08-18T22:22:01.723569Z" + "iopub.execute_input": "2026-08-23T17:16:35.393386Z", + "iopub.status.busy": "2026-08-23T17:16:35.393197Z", + "iopub.status.idle": "2026-08-23T17:16:35.398241Z", + "shell.execute_reply": "2026-08-23T17:16:35.397614Z" } }, "outputs": [ @@ -707,7 +924,7 @@ "(An extensive form game with 2 players, True)" ] }, - "execution_count": 13, + "execution_count": 18, "metadata": {}, "output_type": "execute_result" } @@ -725,99 +942,141 @@ }, { "cell_type": "markdown", - "id": "45db887f", + "id": "b7dfd7d5", "metadata": {}, "source": [ - "Games can be written to and read from Gambit's `.efg` format, so a tree built in Sage can be opened in the Gambit GUI and vice versa." + "Games can be written to and read from Gambit's `.efg` format, so a tree built in Sage can be opened in the Gambit GUI and vice versa.\n", + "As in the strategic form, `save_efg` writes the game the object holds and so is an ordinary method, while `load_efg` builds a new game from a file and so is a class method." ] }, { "cell_type": "code", - "execution_count": 14, - "id": "a915228c", + "execution_count": 19, + "id": "02488d73", "metadata": { "execution": { - "iopub.execute_input": "2026-08-18T22:22:01.724882Z", - "iopub.status.busy": "2026-08-18T22:22:01.724812Z", - "iopub.status.idle": "2026-08-18T22:22:01.727217Z", - "shell.execute_reply": "2026-08-18T22:22:01.726892Z" + "iopub.execute_input": "2026-08-23T17:16:35.399604Z", + "iopub.status.busy": "2026-08-23T17:16:35.399427Z", + "iopub.status.idle": "2026-08-23T17:16:35.404528Z", + "shell.execute_reply": "2026-08-23T17:16:35.403939Z" } }, "outputs": [ { - "name": "stdout", - "output_type": "stream", - "text": [ - "EFG 2 R \"Untitled extensive game\" { \"Alice\" \"Bob\" }\n", - "\"\"\n", - "\n", - "c \"\" 1 \"\" { \"High\" 1/2 \"Low\" 1/2 } 0\n", - "p \"\" 1 1 \"\" { \"bet\" \"check\" } 0\n", - "p \"\" 2 1 \"\" { \"call\" \"fold\" } 0\n", - "t \"\" 1 \"High,bet,call\" { 2, -2 }\n", - "t \"\" 2 \"High,bet,fold\" { 1, -1\n" - ] + "data": { + "text/plain": [ + "(An extensive form game with 2 players, 3)" + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" } ], "source": [ "path = tmp_filename(ext=\".efg\")\n", "poker.save_efg(path)\n", "\n", - "with open(path) as handle:\n", - " print(handle.read()[:220])" + "reloaded = ExtensiveFormGame.load_efg(path)\n", + "reloaded, len(reloaded.infosets)" + ] + }, + { + "cell_type": "markdown", + "id": "f997d2f4", + "metadata": {}, + "source": [ + "## The game catalog\n", + "\n", + "As in the strategic form case, Gambit's catalog of games from the literature is available directly, through the same pair of class methods. `ExtensiveFormGame.gambit_catalog_games` lists only the tree games, since those are the ones that keep their structure here." ] }, { "cell_type": "code", - "execution_count": 15, - "id": "3a1e9237", + "execution_count": 20, + "id": "dc58a657", "metadata": { "execution": { - "iopub.execute_input": "2026-08-18T22:22:01.728051Z", - "iopub.status.busy": "2026-08-18T22:22:01.727979Z", - "iopub.status.idle": "2026-08-18T22:22:01.730216Z", - "shell.execute_reply": "2026-08-18T22:22:01.729921Z" + "iopub.execute_input": "2026-08-23T17:16:35.405962Z", + "iopub.status.busy": "2026-08-23T17:16:35.405786Z", + "iopub.status.idle": "2026-08-23T17:16:35.429807Z", + "shell.execute_reply": "2026-08-23T17:16:35.428939Z" } }, "outputs": [ { "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
GameTitle
0journals/ijgt/selten1975/fig1Selten's horse (Selten IJGT 1975, Figure 1)
1journals/ijgt/selten1975/fig3Selten (IJGT 1975) Figure 3
\n", + "
" + ], "text/plain": [ - "(An extensive form game with 2 players, 3)" + " Game Title\n", + "0 journals/ijgt/selten1975/fig1 Selten's horse (Selten IJGT 1975, Figure 1)\n", + "1 journals/ijgt/selten1975/fig3 Selten (IJGT 1975) Figure 3" ] }, - "execution_count": 15, + "execution_count": 20, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "reloaded = ExtensiveFormGame()\n", - "reloaded.load_efg(path)\n", - "reloaded, len(reloaded.infosets)" + "ExtensiveFormGame.gambit_catalog_games(n_players=3)" ] }, { "cell_type": "markdown", - "id": "8eedd88c", + "id": "5f393739", "metadata": {}, "source": [ - "## The game catalog\n", - "\n", - "As in the strategic form case, Gambit's catalog of games from the literature is available directly.\n", "Selten's horse is the classic example of a Nash equilibrium that is not sequentially rational." ] }, { "cell_type": "code", - "execution_count": 16, - "id": "c1c7dce7", + "execution_count": 21, + "id": "ef08e1d5", "metadata": { "execution": { - "iopub.execute_input": "2026-08-18T22:22:01.731128Z", - "iopub.status.busy": "2026-08-18T22:22:01.731056Z", - "iopub.status.idle": "2026-08-18T22:22:01.733792Z", - "shell.execute_reply": "2026-08-18T22:22:01.733487Z" + "iopub.execute_input": "2026-08-23T17:16:35.431469Z", + "iopub.status.busy": "2026-08-23T17:16:35.431251Z", + "iopub.status.idle": "2026-08-23T17:16:35.436442Z", + "shell.execute_reply": "2026-08-23T17:16:35.435824Z" } }, "outputs": [ @@ -827,21 +1086,20 @@ "(An extensive form game with 3 players, [[1, 1, 1], [3, 2, 2]])" ] }, - "execution_count": 16, + "execution_count": 21, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "horse = ExtensiveFormGame()\n", - "horse.load_from_gambit_catalog(\"journals/ijgt/selten1975/fig1\", info=False)\n", + "horse = ExtensiveFormGame.load_from_gambit_catalog(\"journals/ijgt/selten1975/fig1\")\n", "\n", "horse, payoff_table(horse, horse.obtain_nash(algorithm=\"enumpure\"))" ] }, { "cell_type": "markdown", - "id": "a3fc7265", + "id": "bf6cd8ae", "metadata": {}, "source": [ "Both are Nash equilibria, but only one of them survives if you insist that every player behave optimally at every information set they might reach.\n", @@ -851,14 +1109,14 @@ }, { "cell_type": "code", - "execution_count": 17, - "id": "2e2693cc", + "execution_count": 22, + "id": "f1b81467", "metadata": { "execution": { - "iopub.execute_input": "2026-08-18T22:22:01.734656Z", - "iopub.status.busy": "2026-08-18T22:22:01.734580Z", - "iopub.status.idle": "2026-08-18T22:22:01.736902Z", - "shell.execute_reply": "2026-08-18T22:22:01.736527Z" + "iopub.execute_input": "2026-08-23T17:16:35.438175Z", + "iopub.status.busy": "2026-08-23T17:16:35.438003Z", + "iopub.status.idle": "2026-08-23T17:16:35.441487Z", + "shell.execute_reply": "2026-08-23T17:16:35.440748Z" } }, "outputs": [ @@ -868,7 +1126,7 @@ "[True, False, False]" ] }, - "execution_count": 17, + "execution_count": 22, "metadata": {}, "output_type": "execute_result" } @@ -881,12 +1139,12 @@ }, { "cell_type": "markdown", - "id": "cdcdca5d", + "id": "9738648b", "metadata": {}, "source": [ "## Case study: the absent-minded driver\n", "\n", - "Every solver in Gambit assumes **perfect recall**. When a game violates that assumption, Gambit will not compute equilibria for it, because the standard theory does not apply.\n", + "Gambit's solvers assume **perfect recall**. When a game violates that assumption they refuse to compute equilibria for it — and they are right to, because the standard theory does not apply.\n", "\n", "The best known such game is Piccione and Rubinstein's absent-minded driver. A driver must take the second of two identical exits. The two junctions look exactly the same, so they lie in one information set, and at each the driver either continues or exits. Since he cannot tell them apart, he cannot condition on which one he is at.\n", "\n", @@ -895,14 +1153,14 @@ }, { "cell_type": "code", - "execution_count": 18, - "id": "bf14b609", + "execution_count": 23, + "id": "e0da0793", "metadata": { "execution": { - "iopub.execute_input": "2026-08-18T22:22:01.737719Z", - "iopub.status.busy": "2026-08-18T22:22:01.737649Z", - "iopub.status.idle": "2026-08-18T22:22:01.739973Z", - "shell.execute_reply": "2026-08-18T22:22:01.739650Z" + "iopub.execute_input": "2026-08-23T17:16:35.443297Z", + "iopub.status.busy": "2026-08-23T17:16:35.443130Z", + "iopub.status.idle": "2026-08-23T17:16:35.446842Z", + "shell.execute_reply": "2026-08-23T17:16:35.446354Z" } }, "outputs": [ @@ -912,38 +1170,71 @@ "(An extensive form game with 1 player, False, 1)" ] }, - "execution_count": 18, + "execution_count": 23, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "driver = ExtensiveFormGame()\n", - "driver.load_from_gambit_catalog(\"journals/geb/gilboa1997/fig1\", info=False)\n", + "driver = ExtensiveFormGame.load_from_gambit_catalog(\"journals/geb/gilboa1997/fig1\")\n", "\n", "driver, driver.is_perfect_recall, len(driver.infosets)" ] }, { "cell_type": "markdown", - "id": "b7dfd7d5", + "id": "6ffa0b96", + "metadata": {}, + "source": [ + "One player, one information set, and no perfect recall. Asking for equilibria says so:" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "id": "c744b4c8", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-23T17:16:35.448253Z", + "iopub.status.busy": "2026-08-23T17:16:35.448093Z", + "iopub.status.idle": "2026-08-23T17:16:35.451768Z", + "shell.execute_reply": "2026-08-23T17:16:35.451085Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Computing equilibria of games with imperfect recall is not supported.\n" + ] + } + ], + "source": [ + "try:\n", + " driver.obtain_nash(algorithm=\"liap\")\n", + "except RuntimeError as error:\n", + " print(error)" + ] + }, + { + "cell_type": "markdown", + "id": "0e3a4a94", "metadata": {}, "source": [ - "One player, one information set, and no perfect recall, so `obtain_nash` is not applicable.\n", - "\n", "What we can still do is hand Gambit a *plan* and ask what it is worth. A plan here is a single number: the probability $p$ of continuing at a junction. Gambit evaluates it exactly." ] }, { "cell_type": "code", - "execution_count": 19, - "id": "02488d73", + "execution_count": 25, + "id": "c2be3c93", "metadata": { "execution": { - "iopub.execute_input": "2026-08-18T22:22:01.740816Z", - "iopub.status.busy": "2026-08-18T22:22:01.740742Z", - "iopub.status.idle": "2026-08-18T22:22:01.743729Z", - "shell.execute_reply": "2026-08-18T22:22:01.743397Z" + "iopub.execute_input": "2026-08-23T17:16:35.453106Z", + "iopub.status.busy": "2026-08-23T17:16:35.452948Z", + "iopub.status.idle": "2026-08-23T17:16:35.457941Z", + "shell.execute_reply": "2026-08-23T17:16:35.457386Z" } }, "outputs": [ @@ -953,7 +1244,7 @@ "[(0, 0), (1/4, 13/16), (1/2, 5/4), (3/4, 21/16), (1, 1)]" ] }, - "execution_count": 19, + "execution_count": 25, "metadata": {}, "output_type": "execute_result" } @@ -975,24 +1266,24 @@ }, { "cell_type": "markdown", - "id": "f997d2f4", + "id": "23a2d8ce", "metadata": {}, "source": [ "Gambit evaluates one plan at a time. Sage can recover the whole function.\n", "\n", - "The value is a polynomial in $p$ of degree two (the driver passes at most two junctions) so five exact sample points are more than enough to reconstruct it by interpolation over `QQ`." + "The value is a polynomial in $p$ of degree two — the driver passes at most two junctions — so five exact sample points are more than enough to reconstruct it by interpolation over `QQ`. No floating point, no curve fitting." ] }, { "cell_type": "code", - "execution_count": 20, - "id": "dc58a657", + "execution_count": 26, + "id": "2a7c9b5b", "metadata": { "execution": { - "iopub.execute_input": "2026-08-18T22:22:01.744588Z", - "iopub.status.busy": "2026-08-18T22:22:01.744516Z", - "iopub.status.idle": "2026-08-18T22:22:01.748349Z", - "shell.execute_reply": "2026-08-18T22:22:01.748106Z" + "iopub.execute_input": "2026-08-23T17:16:35.459541Z", + "iopub.status.busy": "2026-08-23T17:16:35.459375Z", + "iopub.status.idle": "2026-08-23T17:16:35.465665Z", + "shell.execute_reply": "2026-08-23T17:16:35.465061Z" } }, "outputs": [ @@ -1002,7 +1293,7 @@ "-3*p^2 + 4*p" ] }, - "execution_count": 20, + "execution_count": 26, "metadata": {}, "output_type": "execute_result" } @@ -1016,22 +1307,22 @@ }, { "cell_type": "markdown", - "id": "5f393739", + "id": "290c348e", "metadata": {}, "source": [ - "With the value function, finding the best plan is calculus, which we can do with Sage." + "With the value function in hand, finding the best plan is calculus, which is exactly what Sage is for." ] }, { "cell_type": "code", - "execution_count": 21, - "id": "ef08e1d5", + "execution_count": 27, + "id": "4a8d3a41", "metadata": { "execution": { - "iopub.execute_input": "2026-08-18T22:22:01.749317Z", - "iopub.status.busy": "2026-08-18T22:22:01.749245Z", - "iopub.status.idle": "2026-08-18T22:22:02.528075Z", - "shell.execute_reply": "2026-08-18T22:22:02.527687Z" + "iopub.execute_input": "2026-08-23T17:16:35.467002Z", + "iopub.status.busy": "2026-08-23T17:16:35.466837Z", + "iopub.status.idle": "2026-08-23T17:16:36.994661Z", + "shell.execute_reply": "2026-08-23T17:16:36.994075Z" } }, "outputs": [ @@ -1041,7 +1332,7 @@ "[p == (2/3)]" ] }, - "execution_count": 21, + "execution_count": 27, "metadata": {}, "output_type": "execute_result" } @@ -1056,14 +1347,14 @@ }, { "cell_type": "code", - "execution_count": 22, - "id": "bf6cd8ae", + "execution_count": 28, + "id": "5512a160", "metadata": { "execution": { - "iopub.execute_input": "2026-08-18T22:22:02.529200Z", - "iopub.status.busy": "2026-08-18T22:22:02.529104Z", - "iopub.status.idle": "2026-08-18T22:22:02.531358Z", - "shell.execute_reply": "2026-08-18T22:22:02.530986Z" + "iopub.execute_input": "2026-08-23T17:16:36.996060Z", + "iopub.status.busy": "2026-08-23T17:16:36.995871Z", + "iopub.status.idle": "2026-08-23T17:16:36.999270Z", + "shell.execute_reply": "2026-08-23T17:16:36.998706Z" } }, "outputs": [ @@ -1073,7 +1364,7 @@ "(2/3, 4/3)" ] }, - "execution_count": 22, + "execution_count": 28, "metadata": {}, "output_type": "execute_result" } @@ -1085,24 +1376,24 @@ }, { "cell_type": "markdown", - "id": "f1b81467", + "id": "24325d35", "metadata": {}, "source": [ - "So the driver's best plan is to continue with probability $2/3$, worth $4/3$.\n", + "So the driver's best plan is to continue with probability $2/3$, worth $4/3$ — both exact.\n", "\n", - "The interesting part is the comparison with $p = 1/3$, the probability at which the driver, reasoning at a junction about what to do *now*, is indifferent between continuing and exiting. That plan is worth only $1$. Planning ahead and reasoning in the moment give different answers." + "The interesting part is the comparison with $p = 1/3$, the probability at which the driver, reasoning at a junction about what to do *now*, is indifferent between continuing and exiting. That plan is worth only $1$. Planning ahead and reasoning in the moment give genuinely different answers, which is the whole point of the example." ] }, { "cell_type": "code", - "execution_count": 23, - "id": "9738648b", + "execution_count": 29, + "id": "d4fd2ac6", "metadata": { "execution": { - "iopub.execute_input": "2026-08-18T22:22:02.532386Z", - "iopub.status.busy": "2026-08-18T22:22:02.532301Z", - "iopub.status.idle": "2026-08-18T22:22:02.534639Z", - "shell.execute_reply": "2026-08-18T22:22:02.534235Z" + "iopub.execute_input": "2026-08-23T17:16:37.000631Z", + "iopub.status.busy": "2026-08-23T17:16:37.000476Z", + "iopub.status.idle": "2026-08-23T17:16:37.003881Z", + "shell.execute_reply": "2026-08-23T17:16:37.003301Z" } }, "outputs": [ @@ -1112,7 +1403,7 @@ "(1, 4/3)" ] }, - "execution_count": 23, + "execution_count": 29, "metadata": {}, "output_type": "execute_result" } @@ -1123,25 +1414,25 @@ }, { "cell_type": "code", - "execution_count": 24, - "id": "e0da0793", + "execution_count": 30, + "id": "774ca496", "metadata": { "execution": { - "iopub.execute_input": "2026-08-18T22:22:02.535514Z", - "iopub.status.busy": "2026-08-18T22:22:02.535439Z", - "iopub.status.idle": "2026-08-18T22:22:02.610306Z", - "shell.execute_reply": "2026-08-18T22:22:02.609858Z" + "iopub.execute_input": "2026-08-23T17:16:37.005227Z", + "iopub.status.busy": "2026-08-23T17:16:37.005069Z", + "iopub.status.idle": "2026-08-23T17:16:37.144685Z", + "shell.execute_reply": "2026-08-23T17:16:37.144073Z" } }, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "Graphics object consisting of 3 graphics primitives" ] }, - "execution_count": 24, + "execution_count": 30, "metadata": {}, "output_type": "execute_result" } @@ -1155,12 +1446,12 @@ }, { "cell_type": "markdown", - "id": "6ffa0b96", + "id": "0836d3c8", "metadata": {}, "source": [ "The red point is the optimal plan, the green one the point of indifference at a junction.\n", "\n", - "Gambit evaluated the plans, whereas Sage found the function behind them and optimised it, playing into each other nicely.\n", + "Gambit evaluated the plans; Sage found the function behind them and optimised it. Neither step works without the other.\n", "\n", "## Summary\n", "\n", @@ -1170,14 +1461,23 @@ "| Wrap a PyGambit tree | `ExtensiveFormGame(game)` |\n", "| Add a move | `game.append_move(node, player, actions)` |\n", "| Add a move by chance | `game.append_chance_move(node, actions, probs)` |\n", + "| Change chance probabilities | `game.set_chance_probs(node, probs)` |\n", "| Bundle nodes into one information set | `game.append_infoset(node, like)` |\n", "| Attach payoffs | `game.set_outcome(node, label, payoffs)` |\n", + "| Award an existing outcome again | `game.set_outcome(node, outcome)` |\n", + "| Insert a move above a node | `game.insert_move(node, player, actions)` |\n", + "| Cut a subtree | `game.delete_tree(node)` |\n", "| Navigate | `game.root.children['action']` |\n", + "| Inspect | `game.players`, `game.infosets`, `game.outcomes` |\n", "| Check the recall assumption | `game.is_perfect_recall` |\n", "| Solve | `game.obtain_nash(algorithm='enumpure')` |\n", + "| Solve the reduced strategic form | `game.obtain_nash(use_strategic=True)` |\n", + "| Ask for floating point answers | `game.obtain_nash(rational=False)` |\n", "| Draw | `game.plot(backend='sage')`, `game.plot(backend='gtdraw')` |\n", - "| Read and write `.efg` | `game.load_efg(path)`, `game.save_efg(path)` |\n", - "| Catalog | `game.load_from_gambit_catalog()` |\n", + "| Show the tree as text | `game.to_efg()` |\n", + "| Read and write `.efg` | `ExtensiveFormGame.load_efg(path)`, `game.save_efg(path)` |\n", + "| Browse the catalog | `ExtensiveFormGame.gambit_catalog_games()` |\n", + "| Load a catalog game | `ExtensiveFormGame.load_from_gambit_catalog(slug)` |\n", "\n", "Further reading:\n", "\n", diff --git a/doc/tutorials/interoperability_tutorials/sagemath_normal_form.ipynb b/doc/tutorials/interoperability_tutorials/sagemath_normal_form.ipynb index 4b50ff86c..659dc14ed 100644 --- a/doc/tutorials/interoperability_tutorials/sagemath_normal_form.ipynb +++ b/doc/tutorials/interoperability_tutorials/sagemath_normal_form.ipynb @@ -8,7 +8,7 @@ "# Using Gambit with SageMath: strategic form games\n", "\n", "[SageMath](https://www.sagemath.org/) is a general-purpose open-source mathematics system built on top of Python.\n", - "Its `sage.game_theory` module inclludes a `NormalFormGame` class, which integrates Gambit solvers.\n", + "Its `sage.game_theory` module includes a `NormalFormGame` class, which integrates Gambit solvers.\n", "\n", "This tutorial shows how a game can be created and analyzed by the two libraries, walks through each part of the interface, and finishes with two case studies that use SageMath to do things Gambit cannot do on its own: solving a game whose payoffs are *symbols* rather than numbers, and building a game out of a combinatorial object.\n", "\n", @@ -28,10 +28,10 @@ "id": "d1134409", "metadata": { "execution": { - "iopub.execute_input": "2026-08-18T22:21:47.941506Z", - "iopub.status.busy": "2026-08-18T22:21:47.941209Z", - "iopub.status.idle": "2026-08-18T22:21:49.478843Z", - "shell.execute_reply": "2026-08-18T22:21:49.478420Z" + "iopub.execute_input": "2026-08-23T17:12:24.207645Z", + "iopub.status.busy": "2026-08-23T17:12:24.207516Z", + "iopub.status.idle": "2026-08-23T17:12:26.598272Z", + "shell.execute_reply": "2026-08-23T17:12:26.597746Z" } }, "outputs": [ @@ -39,7 +39,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "SageMath 10.10.beta6 | pygambit 16.7.0\n" + "SageMath 10.10.beta8 | pygambit 16.7.0\n" ] } ], @@ -70,10 +70,10 @@ "id": "bb4c86e2", "metadata": { "execution": { - "iopub.execute_input": "2026-08-18T22:21:49.479965Z", - "iopub.status.busy": "2026-08-18T22:21:49.479851Z", - "iopub.status.idle": "2026-08-18T22:21:49.485213Z", - "shell.execute_reply": "2026-08-18T22:21:49.484905Z" + "iopub.execute_input": "2026-08-23T17:12:26.599552Z", + "iopub.status.busy": "2026-08-23T17:12:26.599377Z", + "iopub.status.idle": "2026-08-23T17:12:26.603404Z", + "shell.execute_reply": "2026-08-23T17:12:26.602862Z" } }, "outputs": [ @@ -116,10 +116,10 @@ "id": "863f135f", "metadata": { "execution": { - "iopub.execute_input": "2026-08-18T22:21:49.486229Z", - "iopub.status.busy": "2026-08-18T22:21:49.486152Z", - "iopub.status.idle": "2026-08-18T22:21:49.502014Z", - "shell.execute_reply": "2026-08-18T22:21:49.501616Z" + "iopub.execute_input": "2026-08-23T17:12:26.604567Z", + "iopub.status.busy": "2026-08-23T17:12:26.604446Z", + "iopub.status.idle": "2026-08-23T17:12:26.643128Z", + "shell.execute_reply": "2026-08-23T17:12:26.642485Z" } }, "outputs": [ @@ -153,10 +153,10 @@ "id": "e4fb56bb", "metadata": { "execution": { - "iopub.execute_input": "2026-08-18T22:21:49.503043Z", - "iopub.status.busy": "2026-08-18T22:21:49.502945Z", - "iopub.status.idle": "2026-08-18T22:21:49.505457Z", - "shell.execute_reply": "2026-08-18T22:21:49.505103Z" + "iopub.execute_input": "2026-08-23T17:12:26.644478Z", + "iopub.status.busy": "2026-08-23T17:12:26.644283Z", + "iopub.status.idle": "2026-08-23T17:12:26.648068Z", + "shell.execute_reply": "2026-08-23T17:12:26.647339Z" } }, "outputs": [ @@ -189,10 +189,10 @@ "id": "6608cae6", "metadata": { "execution": { - "iopub.execute_input": "2026-08-18T22:21:49.506382Z", - "iopub.status.busy": "2026-08-18T22:21:49.506304Z", - "iopub.status.idle": "2026-08-18T22:21:49.511185Z", - "shell.execute_reply": "2026-08-18T22:21:49.510930Z" + "iopub.execute_input": "2026-08-23T17:12:26.649329Z", + "iopub.status.busy": "2026-08-23T17:12:26.649185Z", + "iopub.status.idle": "2026-08-23T17:12:26.656284Z", + "shell.execute_reply": "2026-08-23T17:12:26.655796Z" } }, "outputs": [ @@ -222,21 +222,21 @@ "source": [ "## From a Sage game to a Gambit game\n", "\n", - "The other direction is the `_gambit_` method, which every Sage NormalFormGame provides.\n", + "The other direction is the `_gambit_` method, which every Sage `NormalFormGame` provides.\n", "It returns a `pygambit.Game`, so the whole Gambit API is available from there, including writing the game out in Gambit's own strategic form format.\n", - "To test this out, we will load the Prinsoner's Dilemma directly from the SageMath strategic game catalog." + "To test this out, we will load the Prisoner's Dilemma directly from the SageMath strategic game catalog." ] }, { "cell_type": "code", - "execution_count": 26, + "execution_count": 6, "id": "5e49d4cf", "metadata": { "execution": { - "iopub.execute_input": "2026-08-18T22:21:49.512292Z", - "iopub.status.busy": "2026-08-18T22:21:49.512184Z", - "iopub.status.idle": "2026-08-18T22:21:49.514162Z", - "shell.execute_reply": "2026-08-18T22:21:49.513785Z" + "iopub.execute_input": "2026-08-23T17:12:26.657551Z", + "iopub.status.busy": "2026-08-23T17:12:26.657408Z", + "iopub.status.idle": "2026-08-23T17:12:26.662200Z", + "shell.execute_reply": "2026-08-23T17:12:26.661783Z" } }, "outputs": [ @@ -252,10 +252,10 @@ "\"\"\n", "\n", "{\n", - "{ \"\" -2.0, -2.0 }\n", - "{ \"\" 0.0, -5.0 }\n", - "{ \"\" -5.0, 0.0 }\n", - "{ \"\" -4.0, -4.0 }\n", + "{ \"\" -2, -2 }\n", + "{ \"\" 0, -5 }\n", + "{ \"\" -5, 0 }\n", + "{ \"\" -4, -4 }\n", "}\n", "1 2 3 4 \n", "\n" @@ -272,80 +272,114 @@ "id": "0f683478", "metadata": {}, "source": [ - "Two options are worth knowing about:\n", - "\n", - "- `as_integer=True` truncates every payoff to an integer, which is useful when a solver benefits from exact integer arithmetic.\n", - "- `maximization=False` negates every payoff, so a game written down in terms of *costs* is handed to Gambit as a game to be maximised." + "Payoffs are handed to Gambit one at a time, and each keeps the kind of value it is: an exact Sage integer or rational becomes a Gambit `Rational`, an inexact real becomes a Gambit `Decimal`. Nothing is rounded or truncated on the way." ] }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 7, "id": "fecfdf0f", "metadata": { "execution": { - "iopub.execute_input": "2026-08-18T22:21:49.515057Z", - "iopub.status.busy": "2026-08-18T22:21:49.514981Z", - "iopub.status.idle": "2026-08-18T22:21:49.517509Z", - "shell.execute_reply": "2026-08-18T22:21:49.517179Z" + "iopub.execute_input": "2026-08-23T17:12:26.663581Z", + "iopub.status.busy": "2026-08-23T17:12:26.663453Z", + "iopub.status.idle": "2026-08-23T17:12:26.666821Z", + "shell.execute_reply": "2026-08-23T17:12:26.666399Z" } }, "outputs": [ { "data": { + "text/latex": [ + "$\\frac{1}{3}$" + ], "text/plain": [ - "[-2.0, -2, 2.0]" + "Rational(1, 3)" ] }, - "execution_count": 9, + "execution_count": 7, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "g_float = pd._gambit_()\n", - "g_int = pd._gambit_(as_integer=True)\n", + "exact = NormalFormGame([matrix(QQ, [[1/3, 2], [1, 5/7]])])._gambit_()\n", + "exact[\"1\", \"1\"][exact.players[\"1\"]]" + ] + }, + { + "cell_type": "markdown", + "id": "42bda8b9", + "metadata": {}, + "source": [ + "`_gambit_` takes one option. `maximization=False` negates every payoff, so a game written down in terms of *costs* is handed to Gambit as a game to be maximised." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "537d16f8", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-23T17:12:26.668042Z", + "iopub.status.busy": "2026-08-23T17:12:26.667906Z", + "iopub.status.idle": "2026-08-23T17:12:26.671281Z", + "shell.execute_reply": "2026-08-23T17:12:26.670724Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "[-2, 2]" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "g_max = pd._gambit_()\n", "g_min = pd._gambit_(maximization=False)\n", "\n", - "[float(g_float[\"1\", \"1\"][g_float.players[\"1\"]]),\n", - " int(g_int[\"1\", \"1\"][g_int.players[\"1\"]]),\n", - " float(g_min[\"1\", \"1\"][g_min.players[\"1\"]])]" + "[QQ(g_max[\"1\", \"1\"][g_max.players[\"1\"]]),\n", + " QQ(g_min[\"1\", \"1\"][g_min.players[\"1\"]])]" ] }, { "cell_type": "markdown", - "id": "42bda8b9", + "id": "9cc777d6", "metadata": {}, "source": [ "## Saving and loading games\n", "\n", "Because the conversion goes through Gambit, Sage can read and write Gambit's `.nfg` files directly.\n", - "This is the simplest way to move a game between a Sage session and the Gambit GUI, or to keep a game under version control." + "This is the simplest way to move a game between a Sage session and the Gambit GUI, or to keep a game under version control.\n", + "\n", + "`save_nfg` writes the game the object holds, so it is an ordinary method. `load_nfg` builds a *new* game from a file, so it is a class method: call it on the class and it hands you the game back." ] }, { "cell_type": "code", - "execution_count": 10, - "id": "537d16f8", + "execution_count": 9, + "id": "74dbb8a2", "metadata": { "execution": { - "iopub.execute_input": "2026-08-18T22:21:49.518348Z", - "iopub.status.busy": "2026-08-18T22:21:49.518280Z", - "iopub.status.idle": "2026-08-18T22:21:49.521428Z", - "shell.execute_reply": "2026-08-18T22:21:49.521107Z" + "iopub.execute_input": "2026-08-23T17:12:26.672369Z", + "iopub.status.busy": "2026-08-23T17:12:26.672254Z", + "iopub.status.idle": "2026-08-23T17:12:26.676158Z", + "shell.execute_reply": "2026-08-23T17:12:26.675652Z" } }, "outputs": [ { "data": { "text/plain": [ - "Normal Form Game with the following utilities: {(0, 0): [-2.0, -2.0],\n", - " (0, 1): [-5.0, 0.0],\n", - " (1, 0): [0.0, -5.0],\n", - " (1, 1): [-4.0, -4.0]}" + "Normal Form Game with the following utilities: {(0, 0): [-2, -2], (0, 1): [-5, 0], (1, 0): [0, -5], (1, 1): [-4, -4]}" ] }, - "execution_count": 10, + "execution_count": 9, "metadata": {}, "output_type": "execute_result" } @@ -354,69 +388,73 @@ "path = tmp_filename(ext=\".nfg\")\n", "pd.save_nfg(path)\n", "\n", - "reloaded = NormalFormGame()\n", - "reloaded.load_nfg(path)\n", + "reloaded = NormalFormGame.load_nfg(path)\n", "reloaded" ] }, { "cell_type": "markdown", - "id": "9cc777d6", + "id": "15f5764a", "metadata": {}, "source": [ - "One caveat: a `.nfg` file records payoffs as decimals, so a round trip through disk turns exact rationals into floating point numbers.\n", - "If exactness is important, you should keep the Sage object and convert on demand rather than saving and reloading." + "The round trip is exact. Gambit's `.nfg` format records a rational payoff as a fraction rather than a decimal, so a game of exact payoffs survives a trip through the disk unchanged." ] }, { "cell_type": "code", - "execution_count": 11, - "id": "74dbb8a2", + "execution_count": 10, + "id": "1f4c31df", "metadata": { "execution": { - "iopub.execute_input": "2026-08-18T22:21:49.522346Z", - "iopub.status.busy": "2026-08-18T22:21:49.522272Z", - "iopub.status.idle": "2026-08-18T22:21:49.524298Z", - "shell.execute_reply": "2026-08-18T22:21:49.523997Z" + "iopub.execute_input": "2026-08-23T17:12:26.677314Z", + "iopub.status.busy": "2026-08-23T17:12:26.677183Z", + "iopub.status.idle": "2026-08-23T17:12:26.681753Z", + "shell.execute_reply": "2026-08-23T17:12:26.681239Z" } }, "outputs": [ { "data": { "text/plain": [ - "" + "(1/3, Rational Field)" ] }, - "execution_count": 11, + "execution_count": 10, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "parent(reloaded.utilities[(0, 0)][0])" + "fractions = NormalFormGame([matrix(QQ, [[1/3, 2], [1, 5/7]])])\n", + "path = tmp_filename(ext=\".nfg\")\n", + "fractions.save_nfg(path)\n", + "\n", + "back = NormalFormGame.load_nfg(path)\n", + "back.utilities[(0, 0)][0], parent(back.utilities[(0, 0)][0])" ] }, { "cell_type": "markdown", - "id": "15f5764a", + "id": "f480f1f8", "metadata": {}, "source": [ "## The Gambit game catalog\n", "\n", "As SageMath's catalog of normal form games consists of mostly simpler, common games, we extend it by Gambit's catalog. It allows Sage to access a variety of games from the research literature.\n", - "Called with no arguments, `load_from_gambit_catalog` returns a table of what is available." + "\n", + "Listing and loading are two separate class methods. `gambit_catalog_games` returns a table of what is available." ] }, { "cell_type": "code", - "execution_count": 12, - "id": "1f4c31df", + "execution_count": 11, + "id": "e871f78c", "metadata": { "execution": { - "iopub.execute_input": "2026-08-18T22:21:49.525171Z", - "iopub.status.busy": "2026-08-18T22:21:49.525091Z", - "iopub.status.idle": "2026-08-18T22:21:49.539496Z", - "shell.execute_reply": "2026-08-18T22:21:49.539116Z" + "iopub.execute_input": "2026-08-23T17:12:26.682904Z", + "iopub.status.busy": "2026-08-23T17:12:26.682770Z", + "iopub.status.idle": "2026-08-23T17:12:26.703831Z", + "shell.execute_reply": "2026-08-23T17:12:26.703310Z" } }, "outputs": [ @@ -722,35 +760,135 @@ "37 Fig 3 from 'A Note on the Lemke-Howson Algorit... " ] }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "NormalFormGame.gambit_catalog_games()" + ] + }, + { + "cell_type": "markdown", + "id": "4a0ef38f", + "metadata": {}, + "source": [ + "Its keyword arguments are passed on to Gambit's own catalog listing, so the table can be filtered — by the number of players, for instance." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "72d366ce", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-23T17:12:26.704968Z", + "iopub.status.busy": "2026-08-23T17:12:26.704838Z", + "iopub.status.idle": "2026-08-23T17:12:26.716989Z", + "shell.execute_reply": "2026-08-23T17:12:26.716487Z" + } + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
GameTitle
0journals/ijgt/nau2004/sec4Three-player game with a unique Nash solution ...
1journals/ijgt/nau2004/sec5Game with a continuum of completely mixed-stra...
2journals/ijgt/nau2004/sec62x2x4 game with Nash equilibria in the relativ...
3journals/ijgt/selten1975/fig1Selten's horse (Selten IJGT 1975, Figure 1)
4journals/ijgt/selten1975/fig3Selten (IJGT 1975) Figure 3
\n", + "
" + ], + "text/plain": [ + " Game \\\n", + "0 journals/ijgt/nau2004/sec4 \n", + "1 journals/ijgt/nau2004/sec5 \n", + "2 journals/ijgt/nau2004/sec6 \n", + "3 journals/ijgt/selten1975/fig1 \n", + "4 journals/ijgt/selten1975/fig3 \n", + "\n", + " Title \n", + "0 Three-player game with a unique Nash solution ... \n", + "1 Game with a continuum of completely mixed-stra... \n", + "2 2x2x4 game with Nash equilibria in the relativ... \n", + "3 Selten's horse (Selten IJGT 1975, Figure 1) \n", + "4 Selten (IJGT 1975) Figure 3 " + ] + }, "execution_count": 12, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "catalog = NormalFormGame().load_from_gambit_catalog()\n", - "catalog" + "NormalFormGame.gambit_catalog_games(n_players=3)" ] }, { "cell_type": "markdown", - "id": "f480f1f8", + "id": "6b5ce8a5", "metadata": {}, "source": [ - "Passing a name from the `Game` column loads that game.\n", + "`load_from_gambit_catalog` takes a slug from the `Game` column and returns the game.\n", "Here is Bagwell's game on commitment and observability:" ] }, { "cell_type": "code", "execution_count": 13, - "id": "e871f78c", + "id": "818b0d19", "metadata": { "execution": { - "iopub.execute_input": "2026-08-18T22:21:49.540399Z", - "iopub.status.busy": "2026-08-18T22:21:49.540319Z", - "iopub.status.idle": "2026-08-18T22:21:49.543673Z", - "shell.execute_reply": "2026-08-18T22:21:49.543367Z" + "iopub.execute_input": "2026-08-23T17:12:26.718202Z", + "iopub.status.busy": "2026-08-23T17:12:26.718060Z", + "iopub.status.idle": "2026-08-23T17:12:26.721761Z", + "shell.execute_reply": "2026-08-23T17:12:26.721244Z" } }, "outputs": [ @@ -773,14 +911,20 @@ } ], "source": [ - "bagwell = NormalFormGame()\n", - "bagwell.load_from_gambit_catalog(\"journals/geb/bagwell1995\", info=False)\n", - "bagwell" + "NormalFormGame.load_from_gambit_catalog(\"journals/geb/bagwell1995\")" ] }, { "cell_type": "markdown", - "id": "4a0ef38f", + "id": "12fb5b1f", + "metadata": {}, + "source": [ + "That one is a tree game in Gambit's catalog, and a `NormalFormGame` is always a strategic form game, so it arrives as its reduced strategic form: each player's strategies are complete contingent plans rather than single moves. The companion tutorial loads the same game as a tree." + ] + }, + { + "cell_type": "markdown", + "id": "17c23058", "metadata": {}, "source": [ "## Solving games\n", @@ -794,13 +938,13 @@ { "cell_type": "code", "execution_count": 14, - "id": "72d366ce", + "id": "089e7b2a", "metadata": { "execution": { - "iopub.execute_input": "2026-08-18T22:21:49.544533Z", - "iopub.status.busy": "2026-08-18T22:21:49.544464Z", - "iopub.status.idle": "2026-08-18T22:21:49.588159Z", - "shell.execute_reply": "2026-08-18T22:21:49.587762Z" + "iopub.execute_input": "2026-08-23T17:12:26.722976Z", + "iopub.status.busy": "2026-08-23T17:12:26.722820Z", + "iopub.status.idle": "2026-08-23T17:12:26.790181Z", + "shell.execute_reply": "2026-08-23T17:12:26.789741Z" } }, "outputs": [ @@ -823,27 +967,25 @@ }, { "cell_type": "markdown", - "id": "6b5ce8a5", + "id": "908a8a1a", "metadata": {}, "source": [ - "The default answer is *exact*: the mixed equilibrium comes out as `3/4` and `1/4`, not as decimals.\n", - "That is Sage's own vertex enumeration at work.\n", + "The answer is *exact*: the mixed equilibrium comes out as `3/4` and `1/4`, not as decimals.\n", "\n", - "Handing the same game to Gambit's solvers gives the same equilibria as floating point approximations.\n", - "`'enumeration'` stays in Sage, while `'LCP'` and `'enummixed'` are Gambit's.\n", + "That holds whichever solver computes it. `'enumeration'` stays in Sage, while `'LCP'` and `'enummixed'` are Gambit's, and all three agree exactly.\n", "(Sage also offers `'lrs'`, which uses the external `lrslib` package; it is not installed here, so it is left out of the comparison below.)" ] }, { "cell_type": "code", "execution_count": 15, - "id": "818b0d19", + "id": "ab42b2c8", "metadata": { "execution": { - "iopub.execute_input": "2026-08-18T22:21:49.589218Z", - "iopub.status.busy": "2026-08-18T22:21:49.589125Z", - "iopub.status.idle": "2026-08-18T22:21:49.593095Z", - "shell.execute_reply": "2026-08-18T22:21:49.592756Z" + "iopub.execute_input": "2026-08-23T17:12:26.791590Z", + "iopub.status.busy": "2026-08-23T17:12:26.791456Z", + "iopub.status.idle": "2026-08-23T17:12:26.796941Z", + "shell.execute_reply": "2026-08-23T17:12:26.796402Z" } }, "outputs": [ @@ -852,8 +994,8 @@ "output_type": "stream", "text": [ "enumeration [[(0, 1), (0, 1)], [(3/4, 1/4), (1/4, 3/4)], [(1, 0), (1, 0)]]\n", - "LCP [[(0.0, 1.0), (0.0, 1.0)], [(0.7499999999999999, 0.25), (0.24999999999999994, 0.7500000000000001)], [(1.0, 0.0), (1.0, 0.0)]]\n", - "enummixed [[(0.0, 1.0), (0.0, 1.0)], [(0.7499999999999999, 0.25), (0.24999999999999994, 0.7500000000000001)], [(1.0, 0.0), (1.0, 0.0)]]\n" + "LCP [[(0, 1), (0, 1)], [(3/4, 1/4), (1/4, 3/4)], [(1, 0), (1, 0)]]\n", + "enummixed [[(0, 1), (0, 1)], [(3/4, 1/4), (1/4, 3/4)], [(1, 0), (1, 0)]]\n" ] } ], @@ -864,31 +1006,33 @@ }, { "cell_type": "markdown", - "id": "12fb5b1f", + "id": "828a2894", "metadata": {}, "source": [ - "So the two libraries are complementary here too: use Sage's solvers when you want exact answers on a small game, and Gambit's when the game is large enough that exact arithmetic becomes the bottleneck.\n", + "This is what the `rational` argument of `obtain_nash` does, and it defaults to `True`. Sage asks the solvers that have an exact mode — `'LCP'`, `'lp'` and `'enummixed'` — to compute in exact arithmetic throughout. The purely numerical ones (`'gnm'`, `'ipa'`, `'logit'`, `'liap'`, `'enumpoly'`) have no exact mode, so they compute in floating point and Sage then rounds the answer to the exact equilibrium it approximates, keeping the rounding only once Gambit has confirmed in exact arithmetic that it really is one. How far a probability may be moved to be rounded is set by `tolerance`.\n", "\n", - "Sage can also tell you whether the game is degenerate, which is worth checking before trusting an equilibrium count." + "Passing `rational=False` skips all of that and returns what the solver computed." ] }, { "cell_type": "code", "execution_count": 16, - "id": "17c23058", + "id": "61546695", "metadata": { "execution": { - "iopub.execute_input": "2026-08-18T22:21:49.594083Z", - "iopub.status.busy": "2026-08-18T22:21:49.593996Z", - "iopub.status.idle": "2026-08-18T22:21:49.595875Z", - "shell.execute_reply": "2026-08-18T22:21:49.595596Z" + "iopub.execute_input": "2026-08-23T17:12:26.798212Z", + "iopub.status.busy": "2026-08-23T17:12:26.798065Z", + "iopub.status.idle": "2026-08-23T17:12:26.801437Z", + "shell.execute_reply": "2026-08-23T17:12:26.800798Z" } }, "outputs": [ { "data": { "text/plain": [ - "False" + "[[(0.0, 1.0), (0.0, 1.0)],\n", + " [(0.7499999999999999, 0.25), (0.24999999999999994, 0.7500000000000001)],\n", + " [(1.0, 0.0), (1.0, 0.0)]]" ] }, "execution_count": 16, @@ -897,12 +1041,50 @@ } ], "source": [ - "battle.is_degenerate()" + "battle.obtain_nash(algorithm=\"LCP\", rational=False)" ] }, { "cell_type": "markdown", - "id": "089e7b2a", + "id": "15895aa1", + "metadata": {}, + "source": [ + "So exactness is no longer the thing that separates the two libraries: use Sage's solvers when you want its own exact routines on a small game, and Gambit's when the game is large enough that they become the bottleneck.\n", + "\n", + "Sage can also tell you whether the game is degenerate, which is worth checking before trusting an equilibrium count, and whether it is constant sum." + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "17f544c1", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-23T17:12:26.802691Z", + "iopub.status.busy": "2026-08-23T17:12:26.802562Z", + "iopub.status.idle": "2026-08-23T17:12:26.805585Z", + "shell.execute_reply": "2026-08-23T17:12:26.804969Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "(False, False)" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "battle.is_degenerate(), battle.is_constant_sum()" + ] + }, + { + "cell_type": "markdown", + "id": "d041d5a4", "metadata": {}, "source": [ "## Games with more than two players\n", @@ -915,24 +1097,24 @@ }, { "cell_type": "code", - "execution_count": 17, - "id": "908a8a1a", + "execution_count": 18, + "id": "fd8ee4e1", "metadata": { "execution": { - "iopub.execute_input": "2026-08-18T22:21:49.596726Z", - "iopub.status.busy": "2026-08-18T22:21:49.596659Z", - "iopub.status.idle": "2026-08-18T22:21:49.599448Z", - "shell.execute_reply": "2026-08-18T22:21:49.599119Z" + "iopub.execute_input": "2026-08-23T17:12:26.806820Z", + "iopub.status.busy": "2026-08-23T17:12:26.806687Z", + "iopub.status.idle": "2026-08-23T17:12:26.810774Z", + "shell.execute_reply": "2026-08-23T17:12:26.810260Z" } }, "outputs": [ { "data": { "text/plain": [ - "[[(0.0, 1.0), (0.0, 1.0), (0.0, 1.0)], [(1.0, 0.0), (1.0, 0.0), (1.0, 0.0)]]" + "[[(0, 1), (0, 1), (0, 1)], [(1, 0), (1, 0), (1, 0)]]" ] }, - "execution_count": 17, + "execution_count": 18, "metadata": {}, "output_type": "execute_result" } @@ -948,37 +1130,37 @@ }, { "cell_type": "markdown", - "id": "ab42b2c8", + "id": "984ad51b", "metadata": {}, "source": [ "Both \"everyone picks the first option\" and \"everyone picks the second\" are equilibria, as expected.\n", "\n", - "Since Sage's own solvers only handle two players, every algorithm for larger games, comes from the Gambit solver integration. These are: `'gnm'`, `'enumpure'`, `'enumpoly'`, `'liap'`, `'simpdiv'`, `'ipa'` and `'logit'`.\n", + "Since Sage's own solvers only handle two players, every algorithm for larger games comes from the Gambit solver integration. These are: `'gnm'`, `'enumpure'`, `'enumpoly'`, `'liap'`, `'simpdiv'`, `'ipa'` and `'logit'`.\n", "The default for a game with more than two players is `'enumpoly'`, which finds the mixed equilibrium too." ] }, { "cell_type": "code", - "execution_count": 18, - "id": "828a2894", + "execution_count": 19, + "id": "76ef7676", "metadata": { "execution": { - "iopub.execute_input": "2026-08-18T22:21:49.600303Z", - "iopub.status.busy": "2026-08-18T22:21:49.600222Z", - "iopub.status.idle": "2026-08-18T22:21:49.606874Z", - "shell.execute_reply": "2026-08-18T22:21:49.606583Z" + "iopub.execute_input": "2026-08-23T17:12:26.812050Z", + "iopub.status.busy": "2026-08-23T17:12:26.811907Z", + "iopub.status.idle": "2026-08-23T17:12:26.824562Z", + "shell.execute_reply": "2026-08-23T17:12:26.824178Z" } }, "outputs": [ { "data": { "text/plain": [ - "[[(0.0, 1.0), (0.0, 1.0), (0.0, 1.0)],\n", - " [(0.5, 0.5), (0.5, 0.5), (0.5, 0.5)],\n", - " [(1.0, 0.0), (1.0, 0.0), (1.0, 0.0)]]" + "[[(0, 1), (0, 1), (0, 1)],\n", + " [(1/2, 1/2), (1/2, 1/2), (1/2, 1/2)],\n", + " [(1, 0), (1, 0), (1, 0)]]" ] }, - "execution_count": 18, + "execution_count": 19, "metadata": {}, "output_type": "execute_result" } @@ -989,7 +1171,15 @@ }, { "cell_type": "markdown", - "id": "61546695", + "id": "503b6b13", + "metadata": {}, + "source": [ + "`'enumpoly'` is one of the solvers with no exact mode, so the `1/2` above is a rounded answer that Gambit then verified. A game of three or more players can have a genuinely irrational equilibrium, and there the rounding fails and the floating point answer is returned instead." + ] + }, + { + "cell_type": "markdown", + "id": "1ae76060", "metadata": {}, "source": [ "## Plotting a game\n", @@ -999,14 +1189,14 @@ }, { "cell_type": "code", - "execution_count": 19, - "id": "15895aa1", + "execution_count": 20, + "id": "5b711f6b", "metadata": { "execution": { - "iopub.execute_input": "2026-08-18T22:21:49.607706Z", - "iopub.status.busy": "2026-08-18T22:21:49.607639Z", - "iopub.status.idle": "2026-08-18T22:21:49.891222Z", - "shell.execute_reply": "2026-08-18T22:21:49.890842Z" + "iopub.execute_input": "2026-08-23T17:12:26.825863Z", + "iopub.status.busy": "2026-08-23T17:12:26.825727Z", + "iopub.status.idle": "2026-08-23T17:12:27.287971Z", + "shell.execute_reply": "2026-08-23T17:12:27.287488Z" } }, "outputs": [ @@ -1017,7 +1207,7 @@ "Graphics object consisting of 28 graphics primitives" ] }, - "execution_count": 19, + "execution_count": 20, "metadata": {}, "output_type": "execute_result" } @@ -1030,28 +1220,28 @@ }, { "cell_type": "markdown", - "id": "17f544c1", + "id": "6ec1ea0f", "metadata": {}, "source": [ "## Case study 1: a game whose payoffs are symbols\n", "\n", - "So far the tutorial mostly showcased object conversion between the two libraries. Now it gets more interesting.\n", + "Everything so far could be described as file conversion. This is where the integration starts to pay for itself.\n", "\n", - "While Gambit's solvers work on numbers, Sage's symbolic ring works on *expressions*. So we can write down a whole family of games at once by using a `NormalFormGame` which contains expressions instead of explicit numbers and solve it in closed form.\n", + "Gambit's solvers work on numbers. Sage's symbolic ring works on *expressions*, and a `NormalFormGame` is perfectly happy to hold them. So we can write down a whole family of games at once and solve it in closed form.\n", "\n", "The example is Hawk–Dove. Two animals contest a resource worth $v$. Two doves split it; a hawk takes it from a dove; two hawks fight and share the value minus a cost $c$ of injury." ] }, { "cell_type": "code", - "execution_count": 20, - "id": "d041d5a4", + "execution_count": 21, + "id": "40eff1c4", "metadata": { "execution": { - "iopub.execute_input": "2026-08-18T22:21:49.892290Z", - "iopub.status.busy": "2026-08-18T22:21:49.892164Z", - "iopub.status.idle": "2026-08-18T22:21:49.915511Z", - "shell.execute_reply": "2026-08-18T22:21:49.915092Z" + "iopub.execute_input": "2026-08-23T17:12:27.289403Z", + "iopub.status.busy": "2026-08-23T17:12:27.289196Z", + "iopub.status.idle": "2026-08-23T17:12:27.327435Z", + "shell.execute_reply": "2026-08-23T17:12:27.326907Z" } }, "outputs": [ @@ -1064,7 +1254,7 @@ " (1, 1): [1/2*v, 1/2*v]}" ] }, - "execution_count": 20, + "execution_count": 21, "metadata": {}, "output_type": "execute_result" } @@ -1080,7 +1270,7 @@ }, { "cell_type": "markdown", - "id": "fd8ee4e1", + "id": "b1671913", "metadata": {}, "source": [ "In the mixed equilibrium each animal plays Hawk with some probability $p$ that leaves its opponent indifferent between the two behaviours.\n", @@ -1089,14 +1279,14 @@ }, { "cell_type": "code", - "execution_count": 21, - "id": "984ad51b", + "execution_count": 22, + "id": "00206d88", "metadata": { "execution": { - "iopub.execute_input": "2026-08-18T22:21:49.916545Z", - "iopub.status.busy": "2026-08-18T22:21:49.916463Z", - "iopub.status.idle": "2026-08-18T22:21:50.690092Z", - "shell.execute_reply": "2026-08-18T22:21:50.689644Z" + "iopub.execute_input": "2026-08-23T17:12:27.328834Z", + "iopub.status.busy": "2026-08-23T17:12:27.328650Z", + "iopub.status.idle": "2026-08-23T17:12:28.653056Z", + "shell.execute_reply": "2026-08-23T17:12:28.652543Z" } }, "outputs": [ @@ -1106,7 +1296,7 @@ "[p == v/c]" ] }, - "execution_count": 21, + "execution_count": 22, "metadata": {}, "output_type": "execute_result" } @@ -1121,34 +1311,34 @@ }, { "cell_type": "markdown", - "id": "76ef7676", + "id": "6a1a0d3c", "metadata": {}, "source": [ - "The equilibrium share of hawks is $p^* = v/c$. This is a closed form valid for every $v$ and $c$ at once, which no numerical solver could have produced.\n", + "The equilibrium share of hawks is $p^* = v/c$ — a closed form valid for every $v$ and $c$ at once, which no numerical solver could have produced.\n", "Being an ordinary Sage expression, we can now plot it, differentiate it, or take limits of it." ] }, { "cell_type": "code", - "execution_count": 22, - "id": "503b6b13", + "execution_count": 23, + "id": "81e592cd", "metadata": { "execution": { - "iopub.execute_input": "2026-08-18T22:21:50.691171Z", - "iopub.status.busy": "2026-08-18T22:21:50.691084Z", - "iopub.status.idle": "2026-08-18T22:21:50.779731Z", - "shell.execute_reply": "2026-08-18T22:21:50.779340Z" + "iopub.execute_input": "2026-08-23T17:12:28.654471Z", + "iopub.status.busy": "2026-08-23T17:12:28.654291Z", + "iopub.status.idle": "2026-08-23T17:12:28.806994Z", + "shell.execute_reply": "2026-08-23T17:12:28.806435Z" } }, "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAnYAAAHWCAYAAAD6oMSKAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjksIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvJkbTWQAAAAlwSFlzAAAPYQAAD2EBqD+naQAAgBRJREFUeJztnQeYFFXWhj8YclhRRMKCgEgOiohKhpUgioqR1RVBwUVBEVFXUf8VFSRJEJCcJEiSnEGQLCg5B4lDToIgzMDM9P98t7aZbpiCAaZn+p467/PUdHX17ar67rlTdfrUveem8vl8PtwgqVKlMq838dUUI6XPOaWPbwtLlixBqVKlcPvtt6f0qSiKoiiKdaRO6RNQlEBGjx6NvXv3aqUoiqIoyk2gjp2S4jCK+dJLL+H3339Hjhw5zDJs2DB8++23KX1qiqIoimIVqfRRbDJVtD6KvSbr1q1D7969cejQIeTPnx9///vf8fbbbyNbtmzJZCFFURRFsZ9bjtjNmjULVatWRdasWXHbbbehbt26WLt2bYJlN23ahM8//xwVKlRA7ty5kS5dOvP67LPPYvny5UFl4+LicMcddyAiIgJ//PFH0GcrVqwwjhKXwYMHX3WcAgUKmM8S80iP0aKWLVua8vfeey/27duXKN0s16xZM9xzzz1Inz690c/1Z555BmPGjEmROgvEXz9kwoQJ5nh0kq6sl5iYGPTr1w+VK1c2n2fIkAHFihXDZ599hj///BPJRcGCBVG4cGGcO3fOnFPZsmXVqVMURVGUG8V3E/BrXPr27etLlSqVL3fu3L4HHnjAlzlzZrM9S5Ysvq1bt171vUcffdR8ni1bNl/x4sXNd+68806zLSIiwjdq1Kig8vXq1TOfTZ06NWh7p06dLp9Dw4YNgz7bt2+f2X733XcneM6BxMTE+Bo3bmy2lypVynf48OFE6d+zZ8/l886UKZOvdOnSvvvvv993xx13mG333XdfitXZlcfr2LGjec2ZM6evfPnyvhw5cpjzJ2fOnPFVrVrVfJ46dWpf/vz5TT2kS5fObOPxjh496gs1cXFxvocfftg3Z84cX9u2bc35tWrVyqwriqIoipJ4bsmxo1MzdOjQy9v//PPPy45IgwYNrvre+PHjfRs2bLjqpj558mTj2Pztb38z+/DTpUsXs6/3338/6DuPP/64cURy5cp1lQM3fPjwBB2+Kx276Oho33PPPWe2PfTQQ76TJ08mWv/bb79tvteoUSPf2bNngz6jc9a/f/8Uq7Mrj0cnbcCAAeY75NKlS2Yh//znP00ZHn/Xrl2Xv3vq1Cnfs88+az57/vnnfclJixYtfGvXrk3WYyqKoiiKFG7JsXvnnXeu+oxOCD+77bbbbmifn332mfleYARq5cqVZtuDDz54eVtsbKzZd9myZY1jxc/9ESjSpEkTs23QoEEJnjP566+/fHXq1DHvq1evnqBjdC38312/fn3Y1Vlijkd47vycUbqE9LOO8uXLZ6KLe/fuve65rFmzxvfKK6/4HnnkEeOMnj592vfhhx/6mjdv7nviiSd8X3311WXn8losXLjwhpxsRVEURVHiSYNboGnTpldtK126tOmndebMGZw8eRLZs2cP+nz//v344YcfsGbNGpw4cQIXL140248dO2Ze169fj5dfftmsP/DAA8iSJYvpf3b27FnTJ42d7LnvatWqoUyZMvj++++xaNEi06+OLF682LyyT1lC8Lv16tXD0qVL8cQTT+DHH38053sj5MuXz7zyu9Tr78sWDnV2Ja+++mqC2ydNmmReX3zxRVOvV5IpUybUrFkTQ4cONbnlOKDhWnTv3t2U7dixo9H42GOPoWvXrmYQBG139913m/6E77zzzjX3Q7sqiqIoinJz3JJjV6hQoQS3M11FZGSk6Qgf6KTQCXvzzTcRFRXlus9Tp07Fn1yaNKhYsSLmzp2LZcuWGWeBThzxO3aE2xo1aoTDhw9j586dZnABO+InxD/+8Q/jIP3zn//E8OHDkTZt2hvW3aJFC6Plq6++MvvgeVWpUgU1atRAnjx5UrTOrqR48eIJbt+4ceNlB89tEIZ/IMnBgwdxLbZv324GP9BeLHv+/Hnj4NGpI3QcixYtioEDB17XsVMURVEUJYVGxWbOnDnhnaZOfdUsC7t27cIbb7xhHJT333/fROE46pKjX1mON31y6dKlBCM4foeOr4yQ0ZHiKNS8efMGfRb4nYRgrjR/lOxmnDpy//33m8hg7dq1jSPTv39/vPLKK+Zc6tSpg61bt6ZonSXmeIwO+uuDTnNCy4EDB0yZCxcuXLM+GJFjHjrC6F758uUvR1ADnU9GHhVFURRFEZCgeNy4ccYBYaTsm2++Mc4RIzn+x5iMViWE/5EqnTY6M/4pp/xRLX6+e/du44QkxrFjqhE+3v3000/Ro0ePm9bzyCOPYM6cOSYVy+zZs/HRRx8Zx47RxVq1auH06dNIqTpLDKwDQufwf30tXZe2bdtec18PPvigSZHCR8ObN29G9erVgz5nXdBJvV40U1EURVEUSxw7f+40PlpNCPYTS4iHHnoIGTNmxKpVq/Drr7+ayE+g4+ZfX7hw4XX71/mPP336dNOH7L333kOfPn1uSRcdJEbp+Ohx27Zt5lEro3h0IFOqzhJDiRIlLufJSyp+/vln83qlY0dnnFFGPgZXFEVRFEWAY0fnjBw9evSqz+gQTZs2LcHvMSHvww8/bCJXHTp0MNsCHTu/E8eBDHwEyr5qfqfFDX5/ypQpZsACZzdIKMnxzUBnkY94CWdQSKk6SwxMpExGjhxpBmwklWPHx9uVKlUK2s665qPmf//730lyHEVRFEVRUtix48wGhBEyjmz1s2PHDrzwwgvGgXPD78hNnTr1qogcHwHmzJnTfMbHhteK1gXCEZ8TJ040jggdDjo4ieWtt97C2LFjzSCBQBgxnD9//uURvSlZZ9eDj085IpZOHR8dXznzRWxsrImC/utf/0J0dHSiHTsOWqGD64ePizmilwNO/INdFEVRFEUJEb6bIKFZHAJhbrQr88sxKS5znPlnTOCsBpzlwD8LQ7t27S4n/b2S+fPnXz4mv3clL7zwwuXPe/bseUPnzES/adOmNec0duzYROnnzBLcV5o0acz5MMGxXzMX5nNL7PFDVWfXOx5hcuVatWpdLstkz5wBgjNpZMyY8fL2CxcuXLdODh48aMpyVowtW7aYbcyPV7FiRd9TTz3lu3jx4nX3oSiKoijKrZFsETumwuBgA6a7YISNozHZqb5JkyZYvXr15dQYCcF5Uv3RqYQGRiT0aDaxPP300yaiRBidmjx58nW/w5xt7777rolAMa+cP5rGvnaMHDIFSkrXWWL7B3Lgx6hRo8y5MwLpz5VHbRwQwn6Nicnzt2DBAvM6bNgwdOvWzYzm5aAP1qk/MqooiqIoSmhJRe8uxMdQPACdTTqIdDxvNOGzoiiKoihJQ7JF7BTZsH8dB02oU6coiqIoKYc6dsotw8Ece/bs0enAFEVRFCWFUcdOuSXY19CfZ48Jn7me2FG0iqIoiqIkLdrHTlEURVEURQgasVMURVEURRGCOnaKoiiKoihCUMdOURRFURRFCOrYKYqiKIqiCEEdO0VRFEVRFCGoY6coiqIoiiIEdewURVEURVGEoI6doiiKoiiKENSxUxRFURRFEYI6doqiKIqiKEJQx05RFEVRFEUI6tgpiqIoiqIIQR27EOPz+fDnn3+aV0VRFEVRlFCijl2IOXv2LG677TbzGgpGjx4N6ahGGagdZSDdjtL1EdUom1Q+DSWFFEbr6NidOXMGf/vb35J8/1FRUciQIQMkoxploHaUgXQ7StdHVKNsNGJnOd988w2koxploHaUgXQ7StdHVKNsPBWxW7x4Mbp06YLVq1fj8OHDmDRpEurXr3/N7yxatAitW7fG5s2bkSdPHvznP//Bm2++GTYRO0VRFEVRFE9G7P766y/cd9996N27d6LK79mzB48//jiqVKmCtWvX4pNPPkHLli0xYcIEhAvt2rWDdFSjDNSOMpBuR+n6iGqUjacidoGkSpXquhG7jz76CFOnTsXWrVsvb2O0bv369fjll19SPGK3dy8wefIZ5M9/G555BmI5cuQIcuXKBcmoRhmoHe1HbSiDIx64b7jhqYjdjULnrXbt2kHb6tSpg1WrVuHSpUsJfic6Oto4c4FLKDh4EChYEHjvvdvQvTtEM23aNEhHNcpA7Wg/akMZTPPAfcMNdeyu4/HnzJkzaBvfx8TE4MSJEwl+p0OHDiZC51/y5ct3S0PSd+3ahc6dOxuH0R8+52uqVIeQI4fjNP7ySxxGj56CLVu2oGfPnsaZDCx76tQpfPfdd9iwYYOJQM6YMQNr1qxB//79cfz48aCy58+fR9euXbF9+3aMGzcO8+fPx/LlyzFs2DBERkYGlY2NjTV69+3bhxEjRmDp0qVYuHAhxowZg507d5r+jBx9Ffgd1unAgQPx22+/Yfbs2SZqumnTJvTq1ctENQPLnj592jw2z5IlCyZPnoyZM2ea/pEDBgzA0aNHg8peuHDBnDePO3bsWCxYsADLli3D8OHDsX//frRv3x5xcXGmLF/5ntv5OcuxPL/H73M/3F/g/nk8HpfH53nwfDZu3GjOj+cZWJY6qIe6qI86qZe6qT+wLOuH9XTHHXeYemP9sR5Zn6xX1i/rOfA7tAPtQbvQPrQT7cXzpv0Cy9K+tDPtTbvT/mwHbA9sF4Fl2W7YftiOJk6ciDlz5pjzHjx4MA4dOhRUlu2R7ZLtk+2U571kyRKMHDkSe/fuRceOHc3/SeB3cufOjaFDh2LFihWYN28exo8fj23btqF79+44d+5cUFn+f/Xr1w/r1q3D9OnTzUWa63379sXJkyeDyjKVUI8ePcx5s5vE3LlzsXLlSgwZMuSq8+YPsk6dOmH37t0YNWqU6XfLhevcxs9YJvA73Af3xX1y3zwGj8Vj8tiBZQsUKGDOkefKc+a5c51aqCmwLDVTO+uAdcE6Yd2wjg4cOBBUlnXJOmXdso5Z16zza10jeN60HW1IW9KmSXGNKFasWNhdI/i/mFTXCH4/HK8RPG5SXSN4juF4jWC7T6prxOoAjW7XCLH4PAqlT5o06ZplChcu7Pv666+Dti1dutR89/Dhwwl+JyoqynfmzJnLS2RkpCnP9aSmaVPqcJZ583ximTVrlk86qlEGakf7URvKYJYH7htuaMTuGvD5PH89BXLs2DGkSZMG2bNnT/A76dOnN33pApdQUaNG/PrPP0Ms/GUsHdUoA7Wj/agNZXDBA/cNN9SxuwYVKlQw4eBAGMJ98MEHkTZtWqQ0gY7dwoUQS+HChSEd1SgDtaP9qA1lUNgD9w03POXY8Rk9n8Fz8acz4Tr7UZA2bdrg1VdfDRoByz4MzGPHkbHsZ8O+BB988AHCgdy5gbvu+sOs//or9UEkP0sOR/4P1SgDtaP9qA1l8LMH7htueCrdCTtv1ggMc/2PRo0amY6mjRs3Np06WS4wQfF77713OUExU6CEU4LiJk2iMWRIerM+ezZH7UIcrDvWoWRUowzUjvajNpTBGQ/cN9zwVMSuevXqHCxy1UKnjvA10Kkj1apVM6OFOMKHEb4bceqSg3Pnpl9el/oDhaPHpKMaZaB2tB+1oQx6eeC+4YanInYpQagjdseOMQWLs/7QQ4DkEdyKoiiKolwbT0XsJDJgQDuULOmsM21PiPIhpyg6/Y0M1I4ykG5H6fqIapSNRuxCBJM7cmHiyB07doQsYsfEl599lg3ffee8nz4deOIJiIIas2XLBsmoRhmoHe1HbSgDL9jRDY3YhYgWLVqYLNfMyh1KmMVbej47apSOapSB2tF+1IYyGOmB+4YbaVL6BJRbg4M7mPZEsmNHjdJRjTJQO9qP2lAG1Txw33BDI3aWw3n47rwTKFPGeb92LfCHk9pOlEbpqEYZqB3tR20og10euG+4oY6d5aRLl868+h/Hcozz4sUQqVEyqlEGakf7URvKIJ0H7htuqGNnOTn/l+tEcj87v0bJqEYZqB3tR20og5weuG+4oY6d5axmjhMAVasCqVLJdOz8GiWjGmWgdrQftaEMVnvgvuGGpjuxPEHx0aNHL/8yKVcOWLPG2X78OEzfOwkEapSKapSB2tF+1IYyOOqB+4YbGrGznIEDB15eD3wcu2gRRGqUimqUgdrRftSGMhjogfuGGxqxszxiF8jMmfHJiTmlbd++IT2coiiKoihhhkbsQgRnnShRogTKly+P5Joahv3s0qZ11ufNgxh0+hsZqB1lIN2O0vUR1SgbjdhZHrG7cOECMmbMGPQ4duFCZ/3334FChWA9V2qUiGqUgdrRftSGMrjggfuGGxqxs5w+ffoEva9VK35dStTuSo0SUY0yUDvaj9pQBn08cN9wQx07y3nqqaeC3teuLc+xu1KjRFSjDNSO9qM2lIEX7OiGOnaWs8af3+R/lC0LZM/urM+fD8TEQJxGiahGGagd7UdtKIM1HrhvuKGOneXkyJEj6H1EBPDoo876mTPAb79BnEaJqEYZqB3tR20ogxweuG+4oY6d5aRPn/6qbYGPY+fOhUiN0lCNMlA72o/aUAbpPXDfcEMdO8vZtWvXVdukDaBISKM0VKMM1I72ozaUwS4P3DfcUMfOcqpXr37VtrvvBooVc9ZXrHAeyUrTKA3VKAO1o/2oDWVQ3QP3DTfUsbM8QfGIESMS3O6P2sXGAj//DKtx0ygJ1SgDtaP9qA1lMMID9w03NEGx5QmK4+LikDr11f759OnAk086682b09GEtbhplIRqlIHa0X7UhjKI88B9ww1vqhbE119/neB2RqH904vZPoDCTaMkVKMM1I72ozaUwdceuG+4oRE7oRE7Uq0asHixs85+pPfcAyvxwi8v1SgDtaP9qA1lEOeB+4Yb3lQtiA4dOrh+VqdO/PqsWRCpUQqqUQZqR/tRG8qggwfuG25oxM7yiN3+/ftxN4fBJsD69cD99zvrjz1mr3N3LY1SUI0yUDvaj9pQBvs9cN9wQyN2lrNw4ULXz8qUAfLmddY5MvavvyBOoxRUowzUjvajNpTBQg/cN9xQx85yChUq5PpZqlTAE08469HRwIIFEKdRCqpRBmpH+1EbysALdnRDHTvLiabHdg38jp0/BYpEjRJQjTJQO9qP2lAG0R64b7ihjp3lCYqPHz9+zc8ffRTIkMFZnzED8PlgHdfTKAHVKAO1o/2oDWVw3AP3DTfUsQsRLVq0wJYtW/Dbb78hlDzwwAPX/DxTJqBGDWf94EFnQIVtXE+jBFSjDNSO9qM2lMEDHrhvuKGOneVMnTr1umXq1YtfZ9ROokbbUY0yUDvaj9pQBlM9cN9wQ9OdWJ7u5MKFC8iYMeM1y+zbBxQo4Kw/8gjwyy+wisRotB3VKAO1o/2oDWVwwQP3DTc0Ymc5Xbt2vW6Z/PmBUqWc9ZUr2fcA4jTajmqUgdrRftSGMujqgfuGG56M2PXp0wddunTB4cOHUbJkSfTo0QNVqlS55kCI3r17Y+/evSbh4aeffopXX301LCJ2ieXjj4FOnZz1778HEnn6iqIoiqJYhOcidmPHjkWrVq2Mc7Z27Vrj0NWtW9dkqU6Ivn37ok2bNmjbti02b96ML774wgyMmDZtGsKBdu3aJaqczf3sEqvRZlSjDNSO9qM2lEE7D9w33PBcxO7hhx82o2XosPkpXrw46tevn+DcchUrVkSlSpVMhM8PHcNVq1Zh6dKlKR6xO3r0KHLmzHndcjExwF13AX/8AfA0TpwA0qaFFSRWo82oRhmoHe1HbSiDox64b7jhqYjdxYsXsXr1atSuXTtoO98vX77cNclhBn8iuP/BDpm//vorLl26hJRmypQpiSqXJg1Qt66z/uefwLJlsIbEarQZ1SgDtaP9qA1lMMUD9w03POXYnThxArGxsVd58Xx/5MiRBL9Tp04dDBo0yDiEDG4yUjdkyBDj1HF/CTmCjNIFLqGkXLlyiS5r6ywUN6LRVlSjDNSO9qM2lEE5D9w33PCUY+cnFSdRDYAO25Xb/Pzf//2f6YP3yCOPIG3atHj66afRuHFj81lERMRV5fk4l49e/Uu+fPlu+jxHjx6NXbt2oXPnzsZh9PcZ4OuhQ4cwePBgLFmyBHPmzMHEiRNNQuSePXsaZzKw7KlTp8wAkHz5NiN1aufJ+4QJUejfv7/Jzh1Y9vz582Y00fbt2zFu3DjMnz/fRDOHDRuGyMjIoLJ0kql33759GDFihHk0zYmXx4wZg507d5rH11FRUUHfoQM9cOBAk7h59uzZmDRpEjZt2oRevXqZx9WBZU+fPm0GraxcuRKTJ0/GzJkzjYM9YMAAE2YPLMuh7TxvHpf9KBcsWIBly5Zh+PDhpv9k+/btERcXZ8ryle+5nZ+zHMvze/w+98P9Be6fx+NxeXyeB89n48aN5vx4noFlqYN6qIv6qJN6qZv6A8uyflhPa9asMfXG+mM9sj5Zr6xf1nPgd2gH2oN2oX1oJ9qL5037BZalfWln7n/GjBkmt9OGDRtMe2C7CCzLdsP2w3bE9sR2xfNmO2N7CyzL9sh2yfbJdsrzZlscOXKkGWTUsWNHxMTEBH2HfVSHDh2KFStWYN68eRg/fjy2bduG7t2749y5c0Fl+aOpX79+WLduHaZPn276tHKdXShOnjwZVPbs2bNmABTPe8KECZg7d65pM/wBduV58wdZp06dsHv3bowaNQqLFy82C9e5jZ+xzJX/a9wX98l98xg8Fo/JYweWZfvhOfJcec48d65TCzUFlqVmamcdsC5YJ6wb1tGBAweCyrIuWaesW9Yx65p1nphrBG2Y2GsE2wbbCNsK20xC1wi2y3C7RvB/MamuEd9++21YXiN43KS6RlBjOF4j2O6T6hrxbYBGt2uEWHweIjo62hcREeGbOHFi0PaWLVv6qlates3vXrx40RcZGemLiYnx9enTx5c1a1ZfbGzsVeWioqJ8Z86cubzwO6xmroeCSZMm3VD5ypXZp9JZfv/dZwU3qtFGVKMM1I72ozaUgRfs6IanInbp0qUz4Vn+EgiE7zlI4lowWpc3b14TpeOvpnr16iF16qurL3369GaQROASSgoVKnRD5W0cHXujGm1ENcpA7Wg/akMZFPLAfcMNTzl2pHXr1qbPHB+tbN26Fe+9954Jt7/55pvmc6Y2CcxRt2PHDhM6ZhicAyb++c9/mvD5119/jXBg0aJFN1Texn52N6rRRlSjDNSO9qM2lMEiD9w33PBcuhN/gmI++2eC4lKlSpnn91WrVjWfsf8cn/+zPwCh8/fyyy+b/gmM2tWoUcP0wylatGiijhXqdCfsu5EtW7ZEl6e1CxZ0phlLl85Je5I1K8KaG9VoI6pRBmpH+1EbyuC0B+4bbnguYkeaN29unDd27mRHV79TR9jh1O/U+XPcMZExO5zSOWOH2MQ6dckBO+beCBwj4o/aXbwIzJ2LsOdGNdqIapSB2tF+1IYy6O2B+4YbnozYJSfhMqVYIHTm6tRx1hs2BIYPT+kzUhRFURQlKfBkxM7r06ZUr+7MPuHvZxcGeZbh9alhVKMM1I72ozaUQTsP3Dfc0Iid5RE77pf7v1Fefpl58px1DhKuWRNhy81qtAnVKAO1o/2oDWVwxgP3DTc0YhcimNyxRIkSKF++PEIJk2feDM8+G7/+448Ia25Wo02oRhmoHe1HbSiD4R64b7ihjl2IaNGihclyzazcoYSjdG8GzhubMaOzPmkSEBuLsOVmNdqEapSB2tF+1IYyqOGB+4Yb6thZDvPr3QyZMzvOHTl2DFi6FOI02oRqlIHa0X7UhjLY6YH7hhvq2FlORn/Y7SZ47jk7HsfeikZbUI0yUDvaj9pQBhk9cN9wQx07y8mePftNf5fTizFJMZk4EYiLgziNtqAaZaB2tB+1oQyye+C+4YY6dpazbt26m/4uB+nWru2sHzoErFgBcRptQTXKQO1oP2pDGXjBjm5ouhPL050cOXIEuXLluunvf/89p1Fz1lu3Brp2RdhxqxptQDXKQO1oP2pDGRzxwH3DDY3YWc6gQYNu6ftPPQWkSeOsT5jgzCUrTaMNqEYZqB3tR20og0EeuG+4oRE7D04pdiWPPQbMmeOsMzvLgw+m9BkpiqIoinIzaMTO8gTFSTFtSriPjvXC1DCqUQZqR/tRG8qgnQfuG25oxM7yiF1UVBQyZMhwS/s4fhxgVwSOir33XmDHDiBVKoQNSaEx3FGNMlA72o/aUAZRHrhvuKERO8vp1avXLe8jRw6gWjVn/fffgQ0bIE5juKMaZaB2tB+1oQx6eeC+4YY6dpZTv379JNlP4ONYDqKQqDGcUY0yUDvaj9pQBvU9cN9wQx07y1m9enWS7OeZZ+Ifv4ZbP7uk0hjOqEYZqB3tR20og9UeuG+4oY6d5SRVnp48eYCKFZ31rVuBzZsRNnghF5FqlIHa0X7UhjLI5YH7hhvq2FlOGn8SuiTghRfi18eMgUiN4YpqlIHa0X7UhjJI44H7hhvq2FnOnj17kmxfL74IpP5fi/jhh/BJVpyUGsMV1SgDtaP9qA1lsMcD9w031LGznKpVqybZvnLnBmrUcNZ373aSFUvTGK6oRhmoHe1HbSiDqh64b7ihjp3l/MDQWhLy0kvx66NHQ6TGcEQ1ykDtaD9qQxl4wY5uaILiEM48wSU2NhY7duwIWYJi7j8iIiLJ9vfHH06y4osXndcDB4Ak3H1YaAxHVKMM1I72ozaUQawH7htuaMQuRLRo0QJbtmzBbyF+ntmhQ4ck3d/ttwN16zrrR44AixYhxUlqjeGIapSB2tF+1IYy6OCB+4YbGrGzfEqxUDBuHNCggbPepAkwaFBKn5GiKIqiKIlBI3aWE4qJjuvVA7JkiZ+FIjoaKYoXJnNWjTJQO9qP2lAG7Txw33BDI3aWR+wiIyORL1++JN9vw4bAyJHO+pQpwFNPIcUIlcZwQjXKQO1oP2pDGUR64L7hhkbsLGf+/Pkh2W/g6NiUHlwUKo3hhGqUgdrRftSGMpjvgfuGG+rYWU6RIkVCst9atYDs2Z31qVOBc+cgTmM4oRploHa0H7WhDIp44L7hhjp2lnPhwoWQ7Ddt2vgpxniISZMgTmM4oRploHa0H7WhDC544L7hhjp2lnPy5MmQ7ftf/4pf//57iNQYLqhGGagd7UdtKIOTHrhvuKGOXYhgcuISJUqgfPnyCCX33XdfyPZdqRJQqJCzvmABO6MiRQilxnBBNcpA7Wg/akMZ3OeB+4Yb6thZnqB4+vTpIdt3qlRAo0bOus8HjBiBFCGUGsMF1SgDtaP9qA1lMN0D9w03NN2J5elOzp8/j0yZMiFU7NsHFCjgrBcuDGzf7jh8yUmoNYYDqlEGakf7URvK4LwH7htuaMTOcrp16xbS/efPD9So4azv3AmsWAFxGsMB1SgDtaP9qA1l4AU7uqERuxBj45RiV8KBE40bO+vNmgH9+qX0GSmKoiiKkhCejNj16dMHBQsWRIYMGVCuXDksWbLkmuVHjRplOmIyrJs7d2689tprYTPiJjmmTXnuOSBzZmd9zBgn/Uly4oWpYVSjDNSO9qM2lEE7D9w33PBcxG7s2LFo2LChce4qVaqE/v37Y9CgQWagw913331V+aVLl6JatWro3r07nnzySRw8eBBvvvkmChcujEmJSO4W6ojd8ePHkSNHDoQaRuz8KU/o3DVogGQjuTSmJKpRBmpH+1EbyuC4B+4bbnguYsfn7k2aNEHTpk1RvHhx9OjRw8wn17dv3wTLr1ixAgUKFEDLli1NlK9y5cpo1qwZVq1ahXBg4sSJyXIc/+hYMmwYRGpMSVSjDNSO9qM2lMFED9w33PCUY3fx4kWsXr0atWvXDtrO98uXL0/wOxUrVsSBAwcwc+ZMMLh59OhR/Pjjj3jiiScSLB8dHW2idIFLKAl1njw/1ao5AynI3LnAoUNINpJLY0qiGmWgdrQftaEMynvgvuGGpxy7EydOIDY2Fjlz5gzazvdHjhxxdezYx65BgwZIly4dcuXKhWzZsqFXr14Jlu/QoYN59OpfGA28WUaPHo1du3ahc+fOxmH09xng66FDhzB48GAsWrQIc+bMMb9O+Di5Z8+expkMLHvq1CmTMHnDhg2YOnUqZsyYgTVr1pjH0AxXB5blEPGuXbti+/btGDdunJlImU7v8OHDUL/+GVMuLg54/fWfTF1S7759+zBixAjz2HrhwoUYM2YMdu7ciS5duiAqKipo/6zngQMHmvx+s2fPNo+zN23aZOqTj6sDy54+fRq9e/fGL7/8gsmTJxvnmo75gAEDjIMdWJbTx/C8eVw+bl+wYAGWLVuG4cOHY//+/Wjfvj3i4uJMWb7yPbfzc5ZjeX6P3+d+uL/A/fN4PC6Pz/Pg+WzcuNGcH88zsCx1UA91UR91Ui91U39gWdYP64kRYNYb64/1yPpkvbJ+Wc+B34mMjMSwYcOMXWgf2on24nnTfoFlaV/amfam3Wl/tgO2B7aLwLJsN2w/bEdsT2xXPG+2M7a3wLJsj2yXbJ9spzxv9lUdOXIk9u7di44dOyImJiboO6yvoUOHmij4vHnzMH78eGzbts10czh37lxQWf6v9uvXD+vWrTP5qKZNm2bWGVln/9bAsmfPnjWRd573hAkTMHfuXKxcuRJDhgy56rwvXbqETp06Yffu3eb/evHixWbhOrfxM5a58n+N++I+uW8eg8fiMXnswLK0A8+R58pz5rlznVqoKbAsNVM764B1wTph3bCO+GMysCzrknXKumUds65Z54m5RtCGSXmN2LNnT4LXCLZJts3Assl1jWDbSqprBG0SjtcIHjeprhHUGI7XCLb7pLpGdA/Q6HaNEIvPQxw8eJD9CX3Lly8P2t6uXTtf0aJFE/zO5s2bfblz5/Z17tzZt379et/s2bN9pUuX9r3++usJlo+KivKdOXPm8hIZGWmOyfVQMGXKFF9y8fvv7I/pLCVK+Hxxcclz3OTUmFKoRhmoHe1HbSiDKR64b7iRBh7izjvvRERExFXRuWPHjl0VxfPDX0McZPHhhx+a92XKlEHmzJlRpUoV80uAo2QDSZ8+vVmSC/b/Sy44vVjlyhxQAmzZAvAHzyOPyNKYUqhGGagd7UdtKIMCHrhvuOGpR7F8lMr0JgzxBsL3fOSaEAxbp04dXE10Dkk4DCi+XqqWpKZp0/j1/v1lakwJVKMM1I72ozaUwRIP3Dfc8Gy6Ez6br1ChgukTwX4NmzdvRv78+dGmTRuT0oT9Kgj7KbzxxhumX0GdOnVw+PBhtGrVyjh7iXlGH+p0J+wDcccddyC5OH8eyJMHOHMGyJjRGUSRLVtoj5ncGlMC1SgDtaP9qA1lcMoD9w03PBWxIxwEwU6UX375Je6//37TcZodXenUETpu7DDrp3HjxiZFCjvAlipVCi+88AKKFi0aNkOpmY8vOeHUe6++6qwzUfGIEfI0pgSqUQZqR/tRG8qgjwfuG254LmKX3EiYUuxKNm8GSpVy1kuWBDZuBFKlSumzUhRFURTFcxE7aaTEtCl05ipVinfyXFIAJhlemBpGNcpA7Wg/akMZeMGObmjEzvKIHfefEpFAPoL1P5Jt2BD4X5fEkJBSGpMT1SgDtaP9qA1l8KcH7htuaMTOcji4IyV4/nng9tud9XHj2FFVnsbkRDXKQO1oP2pDGQzzwH3DDXXsQgSzdpcoUSLk05rUrFkTKQFHxPojdtHRoY3YpZTG5EQ1ykDtaD9qQxnU9MB9ww117EJEixYtzPQlnG4llHC6lZSiWbP49QEDnDkppGlMLlSjDNSO9qM2lME2D9w33FDHznI4C0ZKUbw4UKWKs751qzMjhTSNyYVqlIHa0X7UhjLI7IH7hhvq2FlOSidgDIzahWomipTWmByoRhmoHe1HbSiDOzxw33BDHTvL2bBhQ4oe/7nngOzZnfUffwROnpSnMTlQjTJQO9qP2lAGGzxw33BDHTvLqVu3booeP0MGoFGj+EEU338vT2NyoBploHa0H7WhDOp64L7hhjp2ljNkyJCUPgW88UZoB1GEg8ZQoxploHa0H7WhDIZ44L7hhiYoDjESpxRLiOrVgUWLnPWffgIefTSlz0hRFEVRvIdG7CwnXKZNad48fr1XL5kaQ4lqlIHa0X7UhjJo54H7hhsasQthgmIusbGx2LFjR8gidtHR0UifPj1SmkuXgIIFgYMHgVSpgF27nPeSNIYS1SgDtaP9qA1lEO2B+4YbGrGzPEHxt99+i3Agbdr4qB372H33nTyNoUQ1ykDtaD9qQxl4wY5uaMTO8j52u3btQqFChRAOHD8O5MvnjI697TbgwAEgSxZZGkOFapSB2tF+1IYy2OWB+4YbGrGznF9//RXhQo4cwMsvO+tnzgAjRsjTGCpUowzUjvajNpTBrx64b7ihjp3l5M6dG+HEO+/Er/fsmTSpT8JNYyhQjTJQO9qP2lAGuT1w33BDHTvLiYiIQDhRtmz8/LGcg5mpT6RpDAWqUQZqR/tRG8ogwgP3DTfUsbOcffv2Idxo2TI4aidRY1KjGmWgdrQftaEM9nngvuGGOnaWU7lyZYQb9es7gyjIjBnAjh3yNCY1qlEGakf7URvKoLIH7htuqGNnOWPGjEG4kSYN8Pbbzjr72PXoIU9jUqMaZaB2tB+1oQzGeOC+4YamO7E8QXFMTAzS0JMKM06fdqJ2584BGTIAkZHAnXfK0piUqEYZqB3tR20ogxgP3Dfc0Iid5QmKO3bsiHAkWzagSRNnPSoK6NtXnsakRDXKQO1oP2pDGXT0wH3DDY3YWZ6gOJzZuxdgfsi4OOCuu9iZ1YneKYqiKIoSGjRiZznhPNFxgQLA888768eOAaNGydOYVKhGGagd7UdtKIN2HrhvuKERO8sjdgcOHEDevHkRrjD598MPO+vFiwObNgGpU8vSmBSoRhmoHe1HbSiDAx64b7ihETvLmTdvHsKZhx6KT1i8dSswa5Y8jUmBapSB2tF+1IYy8IId3VDHznKKMwwW5nzwQfz611/f+DRjNmi8VVSjDNSO9qM2lEFxD9w33FDHznLOnj2LcKdePaBkSWd9+XJgyRJ5Gm8V1SgDtaP9qA1lcNYD9w031LGznNNMGBfmsE9dmzbBUTtpGm8V1SgDtaP9qA1lcNoD9w031LGznNKlS8MGGjQAChZ01ufMAVatkqfxVlCNMlA72o/aUAalPXDfcEMduxDBWSdKlCiB8uXLI5TMupnRCCkAE4B/9FH8+w4d5Gm8FVSjDNSO9qM2lMEsD9w33NB0J5anOzl37hyyZMkCG+AMFPfcAxw+7LzfvBkoUUKWxptFNcpA7Wg/akMZnPPAfcMNjdhZTo8ePWALnHXi/ffj33fqJE/jzaIaZaB2tB+1oQx6eOC+4YZG7EKMl6cUS4hz54D8+YFTp4CICOD3350ZKhRFURRFuXU8GbHr06cPChYsiAwZMqBcuXJYco38G40bN0aqVKmuWkr683ekMLZNm8LI+LvvOuuxsUCXLvI03gyqUQZqR/tRG8qgnQfuG254LmI3duxYNGzY0Dh3lSpVQv/+/TFo0CBs2bIFd99991XlGWm7cOHC5fcxMTG477778M4776Bt27YpHrE7ceIE7rzzTtgEo3WM2jF6lz49sGcPkDu3LI03imqUgdrRftSGMjjhgfuGG56L2HXr1g1NmjRB06ZNTWZqPofPly8f+vbtm2B5OmW5cuW6vKxatQp//PEHXnvtNYQDP/74I2zjjjuAt95y1qOjge7d5Wm8UVSjDNSO9qM2lMGPHrhvuOEpx+7ixYtYvXo1ateuHbSd75dzSoREMHjwYNSsWRP5GXIKAx555BHYyHvvOdE6Qp/6xAl5Gm8E1SgDtaP9qA1l8IgH7htueMqxY2g2NjYWOXPmDNrO90eOHLnu9w8fPmxy4zDa50Z0dLR5/Bq4hJIDBw7ARvjotUkTZ52PZL/5Rp7GG0E1ykDtaD9qQxl4wY5ueMqx88PBD4Gwm+GV2xJi2LBhyJYtG+rXr+9apkOHDubxrX/hY96bZfTo0di1axc6d+5sHEZ/Z1C+Hjp0yEQPd+zYgTlz5mDixImmn2DPnj2NMxlY9tSpUyZh8oYNGzB16lTMmDEDa9asMf0Ljx8/HlT2/Pnz6Nq1K7Zv345x48Zh/vz5JppJ7ZGRkUFl6SRT7759+zBixAgsXboUCxcuxJgxY7Bz50506dIFUVFRQd+hAz1w4ED89ttveOSRn5EmTaz5rHv3S/j99+Dz5pQwvXv3xp49ezB58mTMnDnTRFwHDBiAo0ePBpVlP0ieN4/LfpQLFizAsmXLMHz4cOzfvx/t27dHXFycKctXvud2fs5yLM/v8fvcD/cXuH8ej8fl8XkePJ+NGzea8+N5BpZlf8pevXph06ZNmDRpEmbPnm30Ujf1B5Zl/bCeDh48aOqN9cd6ZH2yXlm/rOfA79AOtAftQvvQTrQXz5v2CyxL+9LOtDftTvuzHbA9sF0ElmW7YfthO2J7YrviebOdsb0FlmV7ZLtk+2Q75XlzENLIkSOxd+9edOzY0fRHvfJchg4dihUrVmDevHkYP348tm3bhu7du5ucU4Fl+SOsX79+WLduHaZPn45p06aZdXaZOHnyZFBZzgnJLhU87wkTJmDu3LlYuXIlhgwZctV5X7p0CZ06dcLu3bsxatQoLF682Cxc5zZ+xjJX/q9xX9wn981j8Fg8Jo99pe15jjxXnjPPnevUQk2BZamZ2lkHrAvWCeuGdcSbUmBZ1iXrlHXLOmZds84Tc42gDZPyGsE2m1zXCP7v8H+I/0v8n2L9JnSN4P9iUl0jeG7heI3gcZPqGsH9hOM1gu0+qa4RYwI0ul0jpOKpwRN8FJspUybTWJ555pnL2999913TIBYtWuT6XVZTkSJFUK9ePdPI3GBj5uKH/wh07kI1eILnff/998NWWrYEevVy1pnjLqHIne0aE4NqlIHa0X7UhjJY54H7hhueitilS5fOpDfhL4FA+L5ixYrX/C6dvt9//90MvLgW6dOnNw5c4BJKfvnlF9hMmzZO4mLy3Xfxs1JI0pgYVKMM1I72ozaUwS8euG+44amIXWC6E4ZwK1SoYELnDH9v3rzZDIho06aNeSzG8Hsg/A5D4QwR3wihTnfCkHP27NlhM4zUdesWH8H79lt5Gq+HapSB2tF+1IYyOOmB+4YbnorYkQYNGphn7V9++aUJ07J/DftD+Ee5coAE+1UEQqeMz+WvF61LCdzStNjERx8BmTI56/37s9OrPI3XQzXKQO1oP2pDGfT1wH3DDc9F7JIbnVIscXz8cfzcsc2bO49lFUVRFEW5MTwXsZOGlGlTPvjAmW6MDBwI7NsnT+O1UI0yUDvaj9pQBu08cN9wQyN2lkfsOIw7a9askMBnnwHt2zvrfOo9aJA8jW6oRhmoHe1HbSiDsx64b7ihETvLYf4gKbRuzSncnPWhQ4Ft2+RpdEM1ykDtaD9qQxkM9sB9ww117EIEkzuWKFEC5cuXRyi5cno0m+EcshxIQeLigE8+kafRDdUoA7Wj/agNZVDbA/cNN9SxCxEtWrQwWa6ZlTuUbN26FZJ4911nujEyaRJzEcnTmBCqUQZqR/tRG8pgqwfuG26oY2c50voQMO1J27bx7xnBy5JFlkYv2DEhVKMMpNtRuj6iGmWjjp3lcGCGNF5/HShSxFlfsgTYvNnJMSgZiXa8EtUoA+l2lK6PqEbZqGNnOZwxQxpp0gAdOsS/79YtB2JjIRqJdrwS1SgD6XaUro+oRtlouhPL050cOnQIefLkgTSYNrtCBWDlSuf9sGFAo0YQi1Q7BqIaZSDdjtL1EdUoG43YWc6QIUMgkVSp4meiIP/9LxAVBbFItWMgqlEG0u0oXR9RjbLRiF2I0SnFbo0nngBmznTW6ej95z9JYRVFURRFkYlG7CxH+rQpHTsyehdn1in12DGIRLodiWqUgXQ7StdHVKNsNGJnecTu0qVLSJs2LSTTtGkcBg92foM0awb06wdxeMGOqlEG0u0oXR9RjbLRiJ3lM09069YN0smV6zv4U0sNHAhs3AhxeMGOqlEG0u0oXR9RjbLRiJ3lEbvdu3fjnnvugWSocdy4e9CmjfO+Vi1gzhxngIUUvGJH1Wg/0u0oXR9RjbLRiJ3l/MI5tzygsVUroEAB5/28efEDKqTgFTtKRzXaj9pQBr944Hrjhjp2lpMvXz54QWOGDMHpT95/n/1EIAav2FE6qtF+1IYyyOeB640b6tgp1vDCC0ClSs769u3sx5jSZ6QoiqIo4YU6dpYTGRkJr2hkn7ru3eP71n3+OXDkCETgJTtKRjXaj9pQBpEeuN64oY6d5VTgvFse0shBxk2aOOt//iknYbHX7CgV1Wg/akMZeMGObqhjZznjx4+H1zR26ADcfruzPmIEsGQJrMeLdpSIarQftaEMxnvgeuOGpjsJMZqgODTJNJmk+K23nPXSpYE1a4A0aWAtmjBUBmpH+1EbyuCSBxJNu6ERO8sTFHcKHCoqlIQ0vvEG8MADzjoTFvfpA6vxqh2loRrtR20og04euN64oRE7yyN2XmbFCvajcNZZtRwpmytXSp+VoiiKoqQcGrGzHC9P5vzII8Drr8cPpPjoI1iLl+0oCdVoP2pDGbTzwPXGDY3YWR6xO3ToEPLkyQPJXEvj8eNAkSLA6dPOew6kqFwZ1uF1O0pBNdqP2lAGhzxwvXFDI3aWM3v2bHhZY44cQPv28e9btABiYmAdXrejFFSj/agNZTDbA9cbN9Sxs5ySJUvC6xqbNQPKlnXWN2wAvv0W1qF2lIHa0X7UhjIo6YF7oxvq2FkOH/F6XWNEhDMq1j8jxf/9H7B7N6xC7SgDtaP9qA1lcMYD90Y31LGznLNnz0I6idHIgRR8DEsuXADefBPw+WANakcZqB3tR20og7MeuDe6oY6d5RQvXhzSSazGr78G8uZ11ufNc2alsAW1owzUjvajNpRBcQ/cG91Qx87yBMVz586FdBKrMWtWoG/f+PfvvQccOwYrUDvKQO1oP2pDGcz1wL3RDU13Ynm6E4abs9KjEcyNanzpJWDMmPj1H35A2KN2lIHa0X7UhjLwgh3d0Iid5Xxr4xDQEGtk8TvucNZHjwZmzEDYo3aUgdrRftSGMvjWA/dGNzRiF2J0SrGUYfhwoFEjZz1fPmDzZudRraIoiqJIRiN2luOFaVNuRmPDhkCtWs56ZCTw6acIa9SOMlA72o/aUAbtPHBvdMOTEbs+ffqgS5cuOHz4sEli2KNHD1SpUsW1fHR0NL788kuMHDkSR44cQd68efHpp5/idf9EpSkYsTt58iSyZ88Oydysxj17gFKlgPPnnRx3S5cCFSsiLFE7ykDtaD9qQxmc9MC90Q3PRezGjh2LVq1aGcds7dq1xqGrW7cu9u/f7/qdF198EfPnz8fgwYOxfft2jB49GsWKFUM4MG7cOEjnZjUWLAh89ZWzzp8vr73mOHnhiNpRBmpH+1EbymCcB+6NbnjOsevWrRuaNGmCpk2bmjw3jNbly5cPfQPzZFwx39yiRYswc+ZM1KxZEwUKFMBDDz2EimES+qlQoQKkcysaW7YEHnrIWd+xI3wfyaodZaB2tB+1oQwqeODe6IanHLuLFy9i9erVqF27dtB2vl++fHmC35k6dSoefPBBdO7cGX//+99RpEgRfPDBB7jA6Q3CgEh2IBPOrWhMkwb4/nsgQwbnPQdKLV6MsEPtKAO1o/2oDWUQ6YF7oxtp4CFOnDiB2NhY5MyZM2g737PvXELs3r0bS5cuRYYMGTBp0iSzj+bNm+PUqVMYMmRIgv3xuAT2sQslqfwTpArmVjXyqXn79sD778c/kl2/HsiSBWGD2lEGakf7URvKIJUH7o1ueCpi52Zwjh9xawRxcXHms1GjRplHsI8//rh5nDts2LAEo3YdOnQwgyX8Cx/z3izsy7dr1y4TLaSz6B/lw9dDhw6ZPn8clDFnzhxMnDgRW7ZsQc+ePY0zGViWTihnwtiwYYOJQM6YMQNr1qxB//79cfz48aCy58+fR9euXU1fQvZRYN9CRjOpl7+AAsvSSabeffv2YcSIEcYBXrhwIcaMGYOdO3eaASpRUVFB36EDPXDgQPz222/mMTed5U2bNqFXr15GS2DZ06dPo3fv3qaeJ0+ebB6HM+I6YMAAHD16NKgsy/C8eVz2o1ywYAGWLVuG4cOHm/6Tf/31NSpXdsYJ7d4N1Ky5ymzn5yzH8vwev8/9cH+B++fxeFwen+fB89m4caM5P55nYFnqoB7qoj7qpF7qpv7Asqwf1hPrkvXG+mM9sj5Zr6xffhb4HdqB9qBdaB/aifbiedN+gWVpX9qZ9qbdaX+2A7YHtovAsmw3bD9sR2xPbFc8b7YztrfAsmyPbJdsn2ynPO8lS5aYAUZ79+5Fx44dERMTE/SdtGnTYujQoVixYgXmzZuH8ePHY9u2bejevTvOnTsXVJY/oPr164d169Zh+vTpmDZtmllnlwl2ig4sy0Sk7FLB854wYYLJOL9y5Urzw+vK87506RI6depkfrDxf3rx4sVm4Tq38TOWufJ/jfviPrlvHoPH4jF57MCyWbJkMefIc+U589y5Ti3UFFiWmqmddcC6YJ2wblhHBw4cCCrLumSdsm5Zx6xr1nlirhG0YVJeI9ghPdyuEfxfvNVrRPv27c31ftasWeaV78PpGsHjJtU1ghrD8RrBdp9U14hZARrdrhFi8XmI6OhoX0REhG/ixIlB21u2bOmrWrVqgt959dVXfYUKFQratmXLFnoIvh07dlxVPioqynfmzJnLS2RkpCnL9VDQt29fn3SSSuPvv/t8mTIxZucss2b5wga1owzUjvajNpRBXw/cG93wVMQuXbp0KFeunPklEAjfuw2GqFSpkvklwl8Lfnbs2IHUqVObtCdXkj59epPWJHAJJc8//zykk1QaCxUCunSJf9+4cfjMJat2lIHa0X7UhjJ43gP3Rjc85diR1q1bY9CgQebRytatW/Hee++ZcPubb75pPm/Tpg1effXVy+Vffvll8+jhtddeM2FcPrb58MMPTQ67jBkzIqVhKFo6SanxrbeAxx931o8eBZo0ceJ3KY3aUQZqR/tRG8qgnwfujW54NkExn/0zQXGpUqXM8/uqVauazxo3bmye/7M/gB8+43/nnXdMPws6ecxrx+f2iXHsdEqx8IMOXZky8dG6774DmjdP6bNSFEVRlFvHcxE7wlGtdN7YuZMdXf1OHWGH00CnjjAZMR/XstMpO6WyA2o4ROu8Mm1KUmvkoOihQ+Pfc7Tsli1IUdSOMlA72o/aUAbtPHBvdMOTEbvkJNQRO/b940g8yYRK4zvvAL17O+v33QdwkFT69EgR1I4yUDvaj9pQBuc8cG90w5MRO0lweLx0QqWxc2egZElnnXntPvkEKYbaUQZqR/tRG8pgoAfujW6oY2c5nOdWOqHSyKfpP/zA0dLO+27dOEIaKYLaUQZqR/tRG8qgrgfujW6oYxcimNyxRIkSKF++PEIJE2BKJ5QaOYiiU6f4940acYYSJDtqRxmoHe1HbSiDjR64N7qhjl2IaNGihUmPwqzcoSRbtmyQTqg1tmzJ+YKd9cOHgddfT/4UKGpHGagd7UdtKINsHrg3uqGOneVkzZoV0gm1xtSpORoauPNO5/20acA33yBZUTvKQO1oP2pDGWT1wL3RDXXsLIdJlqWTHBpz5waGD49/36YNsGQJkg21owzUjvajNpTBVg/cG93QdCeWpzvhpMkJTW0mieTU+NlnQPv2znqePMDatcBdd4X+uGpHGagd7UdtKIMDHrg3uqERO8thQmXpJKfGL74AatRw1g8d4pRyQGxs6I+rdpSB2tF+1IYyGOaBe6MbGrELMTqlmH0cOQKULeu8ks8/B9q2TemzUhRFUZTroxE7y/HCtCnJrTFXLmDMGGdQBfnyS2Du3NAeU+0oA7Wj/agNZdDOA/dGNzRiZ3nELiYmBmnSpIFkUkpjx47OIArCEbPsbxeqLhtqRxmoHe1HbSgDL9jRDY3YWZ6g+JvkzsuRAqSUxv/8B6hXz1ln0uIGDYCLF0NzLLWjDNSO9qM2lME3Hrg3uqERO8sjdnv37kWBAgUgmZTUeOoU8MADwL59zvvmzem0J/1x1I4yUDvaj9pQBns9cG90QyN2lrN06VJIJyU13nEHMH58/HyyffoAAwYk/XHUjjJQO9qP2lAGSz1wb3RDHTvLyZ8/P6ST0hr5ND3QmXv7bV40ZGlMDlSjDKTbUbo+ohplo46d5cQmR5K1FCYcNDZqBLRq5axfugQ89xwQGSlLY6hRjTKQbkfp+ohqlI06dpZzmLPWCydcNHbpAjz6qLN+7BjwzDPAhQuyNIYS1SgD6XaUro+oRtmoY2c5Dz30EKQTLho5cn7sWKBgQef96tXAG28APp8cjaFENcpAuh2l6yOqUTbq2FnOhAkTIJ1w0pg9OzBlCpA5s/N+1Ciga1dZGkOFapSBdDtK10dUo2w03Ynl6U6io6ORPn16SCYcNU6c6PSzI5yhYsYM4LHHZGlMalSjDKTbUbo+ohploxE7yxMUd2HHL+GEo8ZnnwX++19nPS4OePFFYONGWRqTGtUoA+l2lK6PqEbZaMTO8oidknLQoXv+eWDSJOd9vnzAihVAnjxqFUVRFCVl0Iid5XhhouNw1chHsCNGOHnuCNOfPPkkcO6cHI1JiWqUgXQ7StdHVKNsNGJnecTu0KFDyCM8RBTuGo8eBR5+OH7aMc4vO3kyEBEhR2NSoBplIN2O0vUR1SgbjdhZzqxZsyCdcNeYMycwcyZw223O++nTnWTGN5IGJdw1JgWqUQbS7ShdH1GNslHHznLKlCkD6digsUQJphBwct2R3r2Bb7+VpfFWUY0ykG5H6fqIapSNOnaWc+rUKUjHFo2clWLgwPj3rVs7j2QlabwVVKMMpNtRuj6iGmWjjp3l/PXXX5COTRobNwY++8xZ56PYl18Gfv1VlsabRTXKQLodpesjqlE26thZTrFixSAd2zR++aXj0BHOJfv448C2bbI03gyqUQbS7ShdH1GNslHHznJ++uknSMc2jalSAUOGANWrO+9PngTq1AEOHJCj8WZQjTKQbkfp+ohqlI2mOwnhzBNcYmNjsWPHjpClO2E6FemJj23VeOYMUK0asH69875kSWDxYuCOO+RovBFUowyk21G6PqIaZaMRuxDRokULbNmyBb/99htCSc+ePSEdWzUy/cns2cA99zjvN292EhifPy9H442gGmUg3Y7S9RHVKBuN2IUYnVJM2bULqFgROHbMqYsnnnCmIUubVutGURRFSVo0Ymc5OjVM+FOokBO5y5rVeT9jBtCwIRAbG19G7SgDtaP9qA1l0M4DU8O5oRE7yyN2zEd0R0KdtgQhRePChUDdukBUlPP+9dedvHecc1aKxmuhGmUg3Y7S9RHVKBtPRuz69OmDggULIkOGDChXrhyWLFniWnbhwoVIlSrVVcu26+WvSCZGjx4N6UjRyFGyP/4YPzsFR86+956T706KxmuhGmUg3Y7S9RHVKBvPOXZjx45Fq1at8Omnn2Lt2rWoUqUK6tati/3791/ze9u3b8fhw4cvL4ULF0Y4wPOXjiSN7F/3ww9OlI6wnzYTGkvS6IZqlIF0O0rXR1SjbDzn2HXr1g1NmjRB06ZNUbx4cfTo0QP58uVD3759r/m9u+66C7ly5bq8REREIBzYu3cvpCNN4wsvONE6P19/DXzzzf/CeIKRZseEUI32ozaUwV4PXG/c8JRjd/HiRaxevRq1a9cO2s73y5cvv+Z3y5Yti9y5c+PRRx/Fzz//7FouOjra9KsLXEJJuDiYoUSixkaNgN6949+PGFECXbtCNBLteCWq0X7UhjKI8MD1xg1POXYnTpwwCYNz5swZtJ3vjxw5kuB36MwNGDAAEyZMwMSJE1G0aFHj3C1mptkE6NChgxks4V8YDbyVfhC7du1C586djcPoH+XD10OHDmHw4MGmE+ycOXPMuTFvHvMT0ZkMLMsyTJa8YcMGTJ06FTNmzMCaNWvQv39/HD9+PKjs+fPn0bVrV/Poedy4cZg/f75xeocNG4bIyMigsqxL6t23bx9GjBiBpUuXmj6JY8aMwc6dO9GlSxdERUUFfYf1PHDgQJPfb/bs2Zg0aRI2bdqEXr16mQEmgWVPnz6N3r1749y5c5g8eTJmzpxpHHPa4+jRo0FlL1y4YM6bx+Xj9gULFmDZsmUYPny4eczevn17xMXFmbJ85Xtu5+csx/L8Hr/P/XB/gfvn8XhcHp/nwfPZuHGjOT+eZ2BZ6qAe6qI+6qRe6qZ+f9k//miHdu0uXbb3Bx8AzZv/buqR9cl6Zf2yngP3TzvQHrQL7UM70V48b9ovsCztSzvT3rQ77c92wPbAdhFYlu2G7YftiO2J7YrnzXbG9hZYlu2R7ZLtk+2Udmdf1ZEjR5pfyh07dkRMTEzQd1KnTo2hQ4dixYoVmDdvHsaPH2/6qnbv3t3YOLAs/1f79euHdevWYfr06Zg2bZpZZ2T95MmTQWXPnj1rIu88b/6fzp07FytXrsSQIUOuOu9Lly6hU6dO2L17N0aNGmX+j7lwndv4Gctc+b/GfXGf3DePwWPxmDx2YNmMGTOac+S58px57lynFmoKLEvN1M46YF2wTlg3rKMDBw4ElWVdsk5Zt6xj1jXrPDHXCNowKa8R2bJlC7trBP8Xk+oaQe3hco3gK+uH9cTjst5Yf7d6jaDGcLxGsN0n1TViRoBGt2uEWHwe4uDBgz5KXr58edD2du3a+YoWLZro/dSrV8/35JNPJvhZVFSU78yZM5eXyMhIc0yuh4J+/fr5pCNd41dfcfhE/NKtm08k0u1IVKP9qA1l0M8D1xs3PBWxu/POO0149sro3LFjx66K4l2LRx55xPx6Soj06dObtCaBSyh59tlnIR3pGjl44qOP/rr8vnVroHt3iEO6HYlqtB+1oQye9cD1xg1POXbp0qUz6U0Y4g2E7ytyaoBEwtG0fEQbDjCELh0vaMySpTu++AJBzl2PHhCFF+yoGu1HbSiD/h643rjhuQTF7CPRsGFD82y+QoUKpk8E+zVs3rwZ+fPnR5s2bXDw4EHTr4LwuXyBAgVQsmRJM/iC/QPYN4DP6RPzi0CnFFNuBDp3bdvGv+eACjp5iqIoipIYPBWxIw0aNDDO2pdffon777/fdJxmR1c6dYQ56gJz2tGZ++CDD1CmTBmT+4edVtkpM1zCvF6YNsVLGj//3Fn8vP8+8OWXTu872/GSHSUjXaN0fUQ1ysZzEbvkJtQRO45wypQpEyTjRY1ffQX897/xn3/4IdCpE5AqFazFi3aUiHSN0vUR1Sgbz0XspHG9xMoS8KLG//s/5zGsny5dgLffBuLiYC1etKNEpGuUro+oRtmoY2c59erVg3S8qpF969j/1x+l69MHeP11ICYGVuJVO0pDukbp+ohqlI06diGCyR1LlCiB8uXLI5SsX78e0vGyxn//G+A4Hn8S9e+/B15+mX0/YR1etqMkpGuUro+oRtmoYxciWrRoYbJcMyt3KMmePTuk43WNr7wCjBsHpE3rvB8/njma2E8GVuF1O0pBukbp+ohqlI06dpbDKYykoxodR27qVCBDBqdOOFtOrVrAqVOwBrWjDKTbUbo+ohplo46d5ezYsQPSUY0Ojz0GzJ4NZM3qvF++HKhSBYiMhBWoHWUg3Y7S9RHVKBtNd2J5uhNO9pwvXz5IRjUGs3YtULcucPSo8z5vXmDOHKBECYQ1akcZSLejdH1ENcpGI3aW8z170wtHNQZTtqwTrStUyHl/4ABQubKzLZxRO8pAuh2l6yOqUTYasQsxOqWYEioYsXv8cWDNGuc9uwaNHQs8+aTWuaIoilfRiJ3l6NQw3rVjzpzAwoVAzZrO+wsXgPr1mWoHYYm2VRlIt6N0fUQ1ykYjdpZH7GJjYxHhT3ImFNV4bZjTrlEjYMyY+G0tWwLdusXnvwsH1I4ykG5H6fqIapSNRuwsp3PnzpCOarw26dIBo0YBH38cv61nT+Dpp4GzZxE2qB1lIN2O0vUR1SgbjdiFcOYJLvxlxKHloYrY7du3D/nz54dkVGPiGTIEaNYsftqxMmWA6dOBcBjkp3aUgXQ7StdHVKNsNGJn+cwTixcvhnRUY+LhXLJz5wLZsjnvN2wAHnoIWLUKKY7aUQbS7ShdH1GNslHHznIKFiwI6ajGG6NGDeCXX+LToRw5AlStCkyejBRF7SgD6XaUro+oRtmoY2c5Mf5nboJRjTdOsWLAihVOfjv/iFlOS/bNN4DPhxRB7SgD6XaUro+oRtmoY2c5RxiOEY5qvDnuvBP46SfglVec93ToPvwQ+Pe/gehoJDtqRxlIt6N0fUQ1ykYdO8spV64cpKMab5706YHhw4EvvojfNmiQ87j28GEkK2pHGUi3o3R9RDXKRh07y5mc0h2nkgHVeGukSgX897/ADz8AGTI429gHj/cvviYXakcZSLejdH1ENcpG051YnqA4KioKGfx3a6GoxqRj9WrgmWc4CbjzPm1aoHdv5/FsqFE7ykC6HaXrI6pRNhqxs5xv2BteOKox6WCUjs5d9erO+0uXnLx3XELd707tKAPpdpSuj6hG2WjEzvIExYpyM9Ch40CKb7+N31ahAvDjj0CePFqniqIotqIRO8sTFOtkzjJIbjvyEWyPHs7ACg6wIOxv98ADwM8/h+aY2lZlIN2O0vUR1SgbjdhZ3seOw9Zz5coFyajG5O13lzo1L/zARx8560mF2lEG0u0oXR9RjbLRiJ3lTJs2DdJRjcnT7652bed9XBzwySfAk08Cp04l3XHUjjKQbkfp+ohqlI06dpZz//33QzqqMfTkyAHMnAm0beukRyF8z0ezv/6aNMdQO8pAuh2l6yOqUTbq2FnOyZMnIR3VmDxERACffw7Mnu3MWkH27QMqVXKmImMk71ZQO8pAuh2l6yOqUTbq2FnOBU4CKhzVmLzwkezatc4oWcKpMzmCtm5d9s25+f2qHWUg3Y7S9RHVKBt17CyncOHCkI5qTH7y5gUWLXIGUPiZOxe47z5gzpyb26faUQbS7ShdH1GNslHHznJ+DlVuijBCNaYMTInSsaPj0PkHCR47Bjz2mBPBu3jxxvandpSBdDtK10dUo2w03YnlCYq5X6ZTkYxqTHno0DVuDMyaFb/twQeB0aOBe+9N3D7UjjKQbkfp+ohqlI1G7CxPUNyrVy9IRzWmPHfdBUyfDnTv7kTyyKpVQNmyTpJjn+/6+1A7ykC6HaXrI6pRNhqxszxBsaIkN2vWAP/8J7BzZ/y2Z58F+vVz0qYoiqIoKYdG7CxHp4aRgU12ZG47Ond8NOtn4kSgVClg6lQZGm8W1Wg/akMZtPPA9cYNjdhZHrE7ffo0smXLBsmoxvCFDl2zZsCJE/HbXn/deWR7ZXNXO8pAuh2l6yOqUTaejNj16dMHBQsWRIYMGVCuXDksWbIkUd9btmwZ0qRJE1ZZu0eOHAnpqMbwhY9gN250ph/zM2SIkxaF6VICUTvKQLodpesjqlE2nnPsxo4di1atWuHTTz/F2rVrUaVKFdStWxf79++/5vcYcXv11Vfx6KOPIpyoVq0apKMawxumQpkyBRg8GMia1dm2dy9Qowbw/vtMhupsUzvKQLodpesjqlE2nnPsunXrhiZNmqBp06YoXrw4evTogXz58qFv377X/F6zZs3w8ssvo4I/HX+YsGvXLkhHNYY/nF+Wj2A3bOBNw9nGkbLdujnROwbF1Y4ykG5H6fqIapSNpxy7ixcvYvXq1ajNOZMC4Pvly5e7fm/o0KHmH+FzTqQZZqRLlw7SUY32UKAAsGAB0LUrkD69s42jZ6tWZUTvfpw9C9FoW7UftaEM0nng3uiGpxy7EydOmITBOXPmDNrO90dcJsHcuXMnPv74Y4waNcr0r7se0dHRZsBE4BJKrtQiEdVoF6lTA61bB883S6ZPL2BGznImC6loW7UftaEMcnrg3uiGpxw7P6n43CgAn8931TZCJ5CPX7/44gsUKVIkUfvu0KGDGQXrX/iY92YZPXq0iRR27tzZOIz+4dt8PXToEAYPHowJEyZgzpw5mDhxokmI3LNnT+NMBpY9deqUmQVjw4YNmDp1KmbMmIE1a9agf//+OH78eFDZ8+fPo2vXrti+fTvGjRuH+fPnm2jmsGHDEBkZGVSW9UO9+/btw4gRI7B06VIsXLgQY8aMMQ5xly5dEBUVFfQdOtADBw40iZtnz56NSZMmYdOmTSZhJvsxBpblyK3evXubc548eTJmzpxpIq4DBgzA0aNHg8pyUmueN4/LfpQLFiwwg12GDx9u+k+2b98ecXFxpixf+Z7b+TnLsTy/x+9zP9xf4P55PB6Xx+d58Hw2btxozo/nGViWOqiHuqiPOqmXuqk/sCzrh/XEfbLeWH+sR9Yn65X1y3oO/A7tQHvQLrQP7UR78bxpv8CytC/tTHvT7qxLtgO2B7aLwLJsN2w/bEdsT2xXPG+2M7a3wLJsj2yXbJ9spzxvDkJip+y9e/eiY8eOKFw4Bo891v5/SY2d+cfYlbVOHS4HMXToZGzbtg3du3fHuXPngvbPH2H9+vXDunXrMH36dEybNs2ss8vEyZMng8qePXvWdKngefP/Ye7cuVi5ciWGDBly1XlfunQJnTp1wu7du82PtcWLF5uF69zGz1jmyv817ov75L55DB6Lx+SxA8suWrTInCPPlefMc+c6tVBTYFlqpnbWwfjx4zFv3jysWLHCPCE4cOBAUNmYmBhTp6xb1jHrmnWemGsEbZiU14hffvkl7K4R/F9MqmvEl19+GZbXCB43qa4R1BgO1wi268DvsN2z/fP/gP8P/L+42WvElwEa3a4RUvFUuhM+is2UKZNpLM8888zl7e+++65pELwoB8J/xttvvx0RERGXt/EfnlXGbWwc//jHP4K+w8bMxQ//EejchSrdCS8m0n+ZqEb72b0baNQoGkuXpg8adNGzJ/D8804fPQloW7UftaEMjnrg3uiGpyJ2fObO9Cb8JRAI31esWPGq8nTE+IuLTp9/efPNN1G0aFGz/vDDD1/1nfTp05vvBS6hhL/wpKMa7eeee9iXtQsGDIjPb8feDy++CDz+ODtzQwTaVu1HbSgDL9jRDU9F7AhD6Q0bNjQhXI5wZeicDWDz5s3Inz8/2rRpg4MHD5rwe0K0bdvWhNjp2CUGnVJMUYI5cABo3hyYNi1+W4YMwGefAR98ED/oQlEURblxPBWxIw0aNDDP2vn8nYmG2b+G/SHo1JHDhw9fN6ddOOGFaVNUoyw75s3r5L3jrBVcJ1FRjmPH1Cg//wxr0bZqP2pDGbTzwL3RDc9F7JKbUEfs2IE3Y8aMkIxqlGtHpj9p2xb49lsOVorf3rAh8M03wF13wSq0rdqP2lAGFzxwb3TDcxE7idOjSUc1yrUjZ6pgzrtVq4DALqsjRgBFi8L0yYuLgzVoW7UftaEM+njg3uiGOnaW89RTT0E6qlG+HTn9MnOE9+sH+OdfP32aM744ufBsyUygbdV+1IYyeMoD90Y31LGzHOYeko5q9IYdmdiYjty2bc6jWD+//go88gjTpQCHDiGs0bZqP2pDGazxwL3RDXXsQgSTO5YoUQLly5dHKMmRIwekoxq9ZUemnuKgdE5NVqJE/HZuY57wDh2cwRbhiLZV+1EbyiCHB+6NbqhjFyJatGhhslwzK3coYd486ahGb9qxRg1g/XonibH/8exffwGffAKULAlMnsxZYxBWaFu1H7WhDNJ74N7ohjp2lsPpWqSjGr1rR07P/M47nLPZyX3Hx7X+mSw4eUytWsCmTQgbtK3aj9pQBrs8cG90Qx07y6levTqkoxplcCt2vPNOdm8AmBeckTw/8+c7Ay/efhs4dgwpjrZV+1EbyqC6B+6NbqhjZzmcCFo6qlEGSWHH0qUdZ27CBKBAAWcb89/R6bv3XqB9e+dxbUqhbdV+1IYyGOGBe6MbmqDY8gTFcXFxSO1/PiUU1SiDpLYjB1B06wZ8/XWwM5c7N/Dll0Djxs6j3ORE26r9qA1lEOeBe6Mb3lQtiK95VxOOapRBUtuR88tyIMXvvwNvvglERDjbDx8G3ngDKFPGmY82OQdYaFu1H7WhDLxgRzc0YhdiNGJ363jhl5dqvHWY/65NG2e0bCBVqwKdOwfPbBEq1I72ozaUQZwH7htueFO1IDowqZdwVKMMQm3HYsWASZOApUud2Sr8LF7sJDh+4QVg69aQnoK2VQHo9UYGHTxwb3RDI3YhTFDMJTY2Fjt27AhZH7v9+/fj7rvvhmRUowyS0458/Eon7+OPnVQpfvgD/uWXgc8/dwZbJDXaVu1HbSiD/R64N7qhETvLExQvXLgQ0lGNMkhOO6ZKBTz7LLB5MycDB+66y9keFweMHOlE95o2BfbtS9rjalu1H7WhDBZ64N7ohjp2llOoUCFIRzXKICXsmDYt8NZbTkLjjh2BO+6IT5EyeDBQuDB/hAEHDybN8bSt2o/aUAaFPHBvdEMdO8uJjo6GdFSjDFLSjpkzAx99BOzZA3zxBeDvFXHpkhPR4z2gdetbT3KsbdV+1IYyiPbAvdENdews5/jx45COapRBONiRDt1//wvs3Qt8+qnj8BHeA7p3BwoWdPrlnThhr8ZQI12jdH1ENcpGHTvLeeCBByAd1SiDcLLj7bcD7do5EbwPPgAyZnS2nz8PdOoE5M8PvP++kxPPVo2hQrpG6fqIapSNOnaWM3XqVEhHNcogHO2YIwfQpQsnDAfeeQdIly7eweOsFozgNW/uRPhs1ZjUSNcoXR9RjbLRdCeWJyi+cOECMvrDDUJRjTKwwY6RkU4y40GDnCnL/HBqsldecR7TFi1qt8ZbRbpG6fqIapSNRuwsp2vXrpCOapSBDXbMlw/o1ct5RPvhh0CWLM72mBhg2DCgeHGgQQNgwwZ7Nd4q0jVK10dUo2w0Ymd5xE5RlNBx6hTQsyfw7bfA6dPBnz35pDPStmJFJ2+eoihKOKARuxDBWSdKlCiB8uXLI5S0Yw9w4ahGGdhoR+a9a9vWSWTMPHj+RMdk2jSgcmXHsZswwcmNZ6PGG0W6Run6iGqUjUbsLI/YHT16FDlz5oRkVKMMJNiRgyrY/44DLg4cCP6MufCaNv0TLVv+DZkyQSwS7OhlfUQ1ykYjdpYzZcoUSEc1ykCCHemwtWzpjKL9/nugdOn4z7itTZu/gdNTMlfe0aMQiQQ7elkfUY2yUcfOcsqVKwfpqEYZSLIj06K8+iqwfj0wZw5Qs2b8ZydPAl995eTC+/e/ge3bIQpJdvSiPqIaZaOOnYCQunRUowwk2pGDJmrXBubNA9auBWrUOGhSo/hnsxg4EChWzBlo8dNPgM8H65FoRy/pI6pRNurYWc7FixchHdUoA+l2vP9+Pqb9Dbt3O7NZZM0a/9n06UCtWkCpUkC/fsBff8FapNtRuj6iGmWjjp3lFGKPbeGoRhl4xY7MhcfBFUx2zNe8eeM/37IFeOstZxudP+bLsw3pdpSuj6hG2ahjZzmLFi2CdFSjDLxmx9tui3fexo8HqlSJL8eceMyDSx+ifn1g/nx7HtNKt6N0fUQ1ykbTnVie7uT06dPIli0bJKMaZaB2dPrhcWaLH35w+uAFUqQI0KwZ0KgRkD07whbpdpSuj6hG2WjEzvIExb1794Z0VKMM1I5A2bLAkCHOY9r27YG//z2+fnbsAN5/39nGEbfLl4dnFE+6HaXrI6pRNhqxCzE6pZiiKG5cugRMmuQMqPj556s/Z568N98EXnkF0BkJFUVJDBqxsxydGkYGakdv2jFtWuDFF4EFC4CtW4H33gNuvz3+840bgRYtgDx5nJx4fJSb0khvq9L1EdUoG43YWR6x4365f8moRhmoHRPHhQvOYAtG8X755erP2buDffHoEAamVEkupNtRuj6iGmWjETvLGT58OKSjGmWgdkwcGTPG97Fbt85Jj5IlS/znv/3GOWmBXLmAxo05wjF5++JJt6N0fUQ1ysaTjl2fPn1QsGBBZMiQwUytsmTJEteyS5cuRaVKlZA9e3ZkzJgRxYoVQ/fu3REu1KhRA9JRjTJQO944993H6xVw6BDQv7+TBNnP+fPOfLXVqwOFC/PxmjMoI9RIt6N0fUQ1ysZzjt3YsWPRqlUrfPrpp1i7di2qVKmCunXrYv/+/QmWz5w5M95++20sXrwYW7duxWeffWaWAQMGIBzYuXMnpKMaZaB2vHn4yJV97NasAX791YniBT4t3LUL+L//c+anrVMHGDMGiIpCSJBuR+n6iGqUjeccu27duqFJkyZo2rQpihcvjh49eiBfvnzo27dvguXLli2Ll156CSVLlkSBAgXwyiuvoE6dOteM8iUnjCJKRzXKQO2YNHPTso8do3iHDzv58GrWdLYTPpKdOxd46SUgd25n4MXq1Un7qFa6HaXrI6pRNp5y7Dg/3urVq1Gbs3YHwPfL2aElETDKx7LVqlVL8PPo6GgzYCJwCSV8RCwd1SgDtWPSQv+DDty8ec7sFl98ARQsGDy7BR3ABx90HulyerMDB279uNLtKF0fUY2y8ZRjd+LECcTGxiJnzpxB2/n+yJEj1/xu3rx5kT59ejz44INo0aKFifglRIcOHcyIKv/CaODNMnr0aOzatQudO3c2DqN/iDpfDx06hMGDB2Py5MmYM2cOJk6ciC1btqBnz57GmQwse+rUKZMwecOGDZg6dSpmzJiBNWvWoH///jh+/HhQ2fPnz6Nr167Yvn07xo0bh/nz5xtHdtiwYYiMjAwqy7qk3n379mHEiBGmP+LChQsxZswYE+rv0qULoqKigr7Deh44cCB+++03zJ49G5MmTcKmTZvQq1cvM1IrsCyzozOR5vTp043OmTNnGsecj8GPHj0aVPbChQvmvHlcPm5fsGABli1bZjoJ8zF7+/btERcXZ8ryle+5nZ+zHMvze/w+98P9Be6fx+NxeXyeB89n48aN5vx4noFlqYN6qIv6qJN6qZv6A8uyflhPtCHrjfXHemR9sl5Zv6znwO/QDrQH7UL70E60F8+b9gssS/vSzrQ37U77sx2wPbBdBJZlu2H7YTtie+I58bzZztjeAsuyPbJdsn2ynfK8GcUeOXIk9u7di44dOyImJiboOz///DOGDh2KFStWYN68eRg/fjy2bdtm+qyeO3cuqCz/V/v164d169YZ+0+bNs2sM7J+8uTJoLJnz541kXee94QJEzB37lysXLkSQ4YMueq8L126hE6dOmH37t0YNWqU6WLBhevcxs9Y5sr/Ne6L++S+eQwei8fksQPL0nY8R54rz5nnznVqoabAstRM7awD1gXrhHXDOjpw4EBQWdYl65R1yzpmXbPO/deIsWM746OPotG4MeuZjtwGZMgQF5Q25T//Ae6+24ciRSLx3XcX8NlnXW7qGsF6CLdrBP8Xk+oaEfgaTtcIHjeprhHUFo7XCLb7pLpGtA/Q6HaNkIqn0p2w4f397383jb1ChQqXt7MB8J+EDciNPXv2mIbFBvfxxx+bf1Y+or0SNmYufviPQOcuVOlOeBHIxeFxglGNMlA7Ji98WDB2LDB0aMJpU9KnB556ykl+/NhjQLp0iduvdDtK10dUo2w8FbG78847ERERcVV07tixY1dF8a6Eo2hLly6NN954A++99x7atm2bYDlG9ejABS6hZNCgQZCOapSB2jF54aXnjTectCkcD8BHtRw964e/P5kv7+mnnf54HJCxdCkQFx/o86QdpesjqlE2norYkYcfftikOGHKEz+c0/Xpp582Ie3E8NVXX5nQM8PJ10OnFFMUJVzg1Z558EaOdEbOHj9+dZm8eZ3kxw0aOAM1/AMzFEWxA09F7Ejr1q3NrxX2mWH6Ekbf2I/iTU7ICKBNmzZ4ldlB/wf7GfDZPfs3cOHz/2+++caMjg0HdGoYGagdZRDudqST9tBDQM+ewMGDwMyZwMsvOwMx/HCARbdu/BEMFCoEfPyxk2bFHwIId423inR9RDXKxnMRO8JoHTt1Hj58GKVKlTIdM6tWrWo+a9y4sYnEsaMnYQdXdixlH7s0adKgUKFC5nFss2bNkDp16hSP2LFjLRMtS0Y1ykDtGL6cPQtMnuxE8ZguJSbm6jJ8jMtIXv360ShXLr3YSJ62UxlEeeDe6AodOyV0nDlzho6zeQ0FnTt39klHNcpA7WgHJ0/6fIMG+Xy1avl8ERH84X/1Ury4z9e2rc+3ebPPFxfnE4W2Uxl09sC90Q1PRuySk1BH7Ph4uHBgj2iBqEYZqB3tg33wJkxwRte6zUlbpAjw7LPOwpx5tkfytJ3KYKcH7o1ueK6PnTSYM0k6qlEGakf7yJEDYPdj5sZjnzz2zStaNHjExY4dQMeOTt89Tmn27rsAe7Ik9DjXBrSdysALdnRDHTvLkZ5viahGGagd7YYpUd55B+jXbzMiI4Hu3QF2TQ7sasztdP5q1HDKM487B2gEpPYMe7SdyiCXB+6NbqhjFyI4mpZpVMozX0AI4YAO6ahGGagd5diRKVFatXIez3LO2oEDgbp1gbRp48udOAEMHgw88YQT+WM+d+bNC/Esi7eMtlMZpPHAvdENdexCBKcd4/QlnG4llHC0rnRUowzUjjLteNdd8ZE59skbNQp4/nkgU6bgUbcccctRtXfeyfm5mXEASEQq0GRH26kM9njg3uiGDp6wfPAE5wrMz44tglGNMlA7esuOFy44qVMmTgSmTQP++CPhcqVKAU8+6SzspxcRgRRF26kM9nng3uiGRuws54cffoB0VKMM1I7esiOTHnO6su+/B44edZy8t992BlgEsmkTwEl/KlZ0+uW99prjDJ47hxRB26kMfvDAvdENjdhZHrGLjY01899KRjXKQO0og1u1I1Om0JljFI/LypUJp1FJl84ZhFGvntN/j7NgJAfaTmUQ64F7oxsasbOcxM5vazOqUQZqRxncqh2Z5650aeCTT4BffnEGXwwZAjzzDJA5c3y5ixeBOXOckbj33uvMfNGypdOX7/x5hAxtpzLo4IF7oxsasbM8YqcoiiKFqCgnB54/msf0KQmRPj1QrRrw2GNONK9oUfsTIytKUqERO8vRyZxloHaUgdrx1uDUnnTWvvuOnd+Bdeuc/nd04gKzVzAvHvvstW4NFC8OFCwIvPUWMGWKMwJXbajttF27dvAqGrGzPGIXGRmJfPnyQTKqUQZqRxmklB2Z/27+fGDWLGD2bPdoHnPpVaoE1KwJ1KoFlCt3YyNttZ3KINID90Y3NGJneYLi+bzSCUc1ykDtKIOUsiN/F7Mf3oABTjRv82bgm28cB44DLfxcuuQ8zv3sM+Dhh528eZzHtk8fZ/qz682Oru1UBvM9cG90Qx07yxMUF+EM3MJRjTJQO8ogHOzI/nQlSgDvvw/MmwecPOn0yWve3HksG8jp08CkSbwmO33xmG7l9deB0aOdNCzhqC/UqEbZeHfODSFcYBZQ4ahGGagdZRCOdsySxUmLwoXs3g389JOzMHBz6lR8WT7CHTrUWUiZMk7Uj0uVKuGpL6lRjbJRx85yTvKnqnBUowzUjjKwwY733AP8+9/OEhfnDMJgZI+O3pIlzuALPxs2OEu3bs4AjXvuuQ/PPQdUr+4kTabTKA0bbHirnPSARjd08ITlgye2b9+Oony+IBjVKAO1owxstyMDcsuXx0f0Vq9273dHR4/dpOnkSXL0bLdhYtjuAY1uaB87y5k+fTqkoxploHaUge125FRnjz7qpFFhF+gTJ4AffwSaNXP64AUSE+MkUWbZOnWA2293nDsmV2a6lZSa9szrNkwM0z2g0Q2N2FkesTt//jwyZcoEyahGGagdZSDdjrt2nceqVZnMyFou27a5l2VE78EHnWgec+1VqADcdhvCHuk29IpGNzRiZznd2DFEOKpRBmpHGUi34+jR3dCgAdC3L7B1qzPl2ZgxwJtvAsWKXR3RW7EC6NjRmQGDEb377wfeftv5zoEDCEuk29ArGt3QiF2I0SnFFEVR5HDkCLBokRPN4yudv2vB9CqVK8cvTNOSWkMqSgjR5mV5gmIvTJuiGmWgdpSBdDteT1+uXLgc0duyxYnojR0LvPOOE6270mljMuVRo5wpz0qXBrJnd9KyMMq3dKkzP25yI92GXtHohkbsLI/YHT9+HDly5IBkVKMM1I4ykG7HW9V35ozzeJZOG5eVK52RuG5w1gxOe8b+eY884iyhnglLug29otENjdhZzsSJEyEd1SgDtaMMpNvxVvVx8ARH0H71FfDzz87MF3T0OP1Z/frOFGeBXLzojLxll7AXXwTuvhvImxd4/nmga1dg2bKkj+pJt6FXNLqhCYotJ9SPesMB1SgDtaMMpNsxqfUxIsc5a7lwCjTmzOOctf6IHpfffw/+zsGDwIQJzkLSpnUe8/qjenxl3z1OrXYzSLehVzS6oY6d5RxmBw/hqEYZqB1lIN2OodZHZ4z58rg0aeJsYy49PrJl5I7RPa4H5si7dMnJucelZ09nW86cjpNH/+Whh5y0KxyVmxik29ArGt1Qx85yYmNjIR3VKAO1owyk2zEl9PHx7BNPOItzDs7ADDp5fmfvytG3R48CU6Y4i59773UcPb+zV7YskFAqN+k29IpGN9Sxs5wCBQpAOqpRBmpHGUi3Yzjoi4hwRtByeeMNZ9sffwC//hrv7DGqx/57gfCRLpfRo+P3U7JkvLPHhfsMB42hpoAHNLqhgycsZwlntBaOapSB2lEG0u0Yrvr4mJWDMj7/HJg9m5PcO7NijBjhpFrhY9n06YO/w6DVhg3A4MFOgmWOvmVyhqefvst8Z9gw53M+6pXGkjC1Y3Kg6U4sT3dy6tQp3HHHHZCMapSB2lEG0u1osz46aJs2OZE9f588vo+Lu/b36BCWKQM88IDj/PG1VKmrHUWbOGWxHW8VjdhZTp8+fSAd1SgDtaMMpNvRZn0cPct+dc2aAYMGAevXM7jA6JWTTuWll4BCha7+XnS04wT27w/8+9/OQIwsWZx9cYDHd985j4DPn4c19LHYjreKRuxCOPMEF3bg3LFjR8gidoqiKIpyI5w6BaxdC6xZE78wBcv14KwaxYs7ET06fffd5yycTUMJHzRiFyJatGiBLVu24Df+DAohXpg2RTXKQO0oA+l2lK6P9OnTDo8+Cnz4oTPQYvt2Z8YMzn3bvTvQsKEz6OLK6dH4SHfzZqdfX+vWMPvgiF4mVOaI3k8+caZXY9+/lB6U2s4DdnRDI3aW97Hj/qVHAlWjDNSOMpBuR+n6bkQjH71ycEVgZI999hIz2CJDBqefnj+qx4X9+LJlQ7Lwpwfs6IZG7CxnGIc1CUc1ykDtKAPpdpSu70Y0MgceR9s2b+702aNjd/YssGqVM9K2ZUugWrWEnTVOg3ZlOY7sZRaSp58G/vtf4McfgZ07rz+4I5QaJeLJPHbsVNmlSxeTmbpkyZLo0aMHqlSp4jrfXN++fbFu3TpER0eb8m3btkUdjjsPA2rWrAnpqEYZqB1lIN2O0vXdqkaOlOXIWS5+OE1aZKQzWCNwYU49fhbIvn3OMnVqsANZooQT4Qtc8uS5+WnTanrAjm54LmI3duxYtGrVCp9++inWrl1rHLq6deti//79CZZfvHgxatWqhZkzZ2L16tWoUaMGnnzySfPdcGAbOzMIRzXKQO0oA+l2lK4vFBrpfN19N/Dkk8BnnwHjxzuDMRjdYzLlfv2cqF+lSkDWrAk/8mV0j0G2Dz4AHnvM6bfHbCWVKzs5+Hr3BhYudKZfSwmNNuG5iF23bt3QpEkTNG3a1LxntG7OnDkmKtehQ4eryvPzQL7++mtMmTIF06ZNQ1kOC0phMmfODOmoRhmoHWUg3Y7S9SWnRh6Gj3K5+OFj1717gyN77Le3a9fV0T3OrLFsmbMEwnlyObgjMLrH94Fd6jJ7wI5ueMqxu3jxoom6ffzxx0Hba9eujeXLlydqH3FxcTh79mzYJD4Ml/MIJapRBmpHGUi3o3R9Ka2RI23vucdZnnkmOGrH+XA56paOnn/hI94r4Ty5XBYsCN6eL5/j4PGxbsaMRczcuQnl7ZOOpx7FnjhxwuSVy0l3PwC+P3LkSKL20bVrV/z111948cUXE/yc/fA4GidwCSUbOGRJOKpRBmpHGUi3o3R94aqR/ezYb+/VV4HOnYGZMwH2kPJH7QYMcAZh/OMfwF13JbwPOoGzZzvJmNu3L2jWvYinHDs/qa7ojenz+a7alhCjR482AyfYT+8ul5bFx7lMb+Jf8vEnxE3C4+3atQudO3c2DqM/Lw9fDx06hMGDByN37tzmUTIHeTBvXs+ePY0zGViWU6swWTL/madOnYoZM2ZgzZo16N+/P44fPx5U9vz588Z53b59O8aNG4f58+ebaCZHGEVGRgaVpZNMvfv27cOIESOwdOlSLFy4EGPGjMHOnTvNAJWoqKig79CBHjhwoMnvN3v2bEyaNAmbNm1Cr169TEqYwLKnT59G7969zWTOkydPvtzPccCAATh69GhQ2QsXLpjz5nFpnwULFmDZsmUYPny46T/Zvn17E21lWb7yPbfzc5ZjeX6P3+d+uL/A/fN4PC6Pz/Pg+WzcuNGcH88zsCx1UA91UR91Ui91U39gWdYP66lo0aKm3lh/rEfWJ+uV9ct6DvwO7UB70C60D+1Ee/G8ab/AsrQv7Ux70+60P9sB2wPbRWBZthu2H7Yjtie2K5432xnbW2BZtke2S7ZPtlOeN+dmHDlyJPbu3YuOHTsiJiYm6Dv33Xcfhg4dihUrVmDevHkYP3686QfTvXt3nDt3Lqgsf4T169fPDFqaPn266frAdXaZOHnyZFBZRtDZZYLnPWHCBMydOxcrV67EkCFDrjrvS5cuoVOnTti9ezdGjRpl+tBy4Tq38TOWufJ/jfviPrlvHoPH4jF57MCyDz/88OXBVjxnnjvXqYWaAstSM7WzDlgXrBPWDevowIEDQWVZl6xT1i3rmHXNOk/MNYI2TMprRPXq1cPuGsH/xaS6RlBXOF4jeNykukZwPRyvEWz3V14jDh/ehpUru+Oll84hR452mD+fc+O2w5YtJ9Gq1VR89NEBPPbYPhQvfgpZsgQnz2Pk7lrXCLH4PER0dLQvIiLCN3HixKDtLVu29FWtWvWa3x0zZowvY8aMvunTp1+zXFRUlO/MmTOXl8jISPYaMOuh4KuvvvJJRzXKQO0oA+l2lK5Pssa4OJ/v4EGfb948n+/xx2f7Tp70eRLPJSjmL+py5coFzSNXokQJPP300wkOniD8tfH666+b1/r164dVgmJFURRFURTPPopt3bo1Bg0aZB6tbN26Fe+9954Jt7/J8dQA2rRpg1f5kP9/0Jnje4awH3nkERMm50JHLRzwwrQpqlEGakcZSLejdH1ENcrGcxE7wmgdn/0zQXGpUqVMP5eqVauazxo3bmye/7M/AGF/kkWcQO8KGjVqlKjM1qGO2LEfQ3pmjBSMapSB2lEG0u0oXR9RjfJgH0L25WSeXs9F7Ejz5s2N88bGzY6ufqeO0FnzO3WE6/R9r1zCZbqSb7/9FtJRjTJQO8pAuh2l6yOqUaZj98UXXxjnzpOOnSSee+45SEc1ykDtKAPpdpSuj6hG2XjyUWxyooMnFEVRFEUJJUwLxvQ3e/bs0YhdqMmaNavpX8dXRVEURVHsJyYmxuQd5Pzx2bNnR4YMGXDPPfeYaCinHb0S5t/8z3/+Y3KWZsyYEbfffrvpw88cmgnF1+ikNWvWzOyTfT7pQ3D9mWeeMfkM/bBbGPPwsjwpWLCgRuwURVEURVESyx9//IEnn3zSJK4m+fPnR44cOUyGjWPHjpn37Mfv5/fff8c//vEPkzg6Xbp0ZtAm+8IxKTph5g2/g0b43fLly5uk5pkyZUKhQoUQERFh9s+k0Uz2zsTnZNasWSaZ9qpVq8y4gQcffFAjdoqiKIqiKImFeW3p1NHh4iwZdMQ4AwdnH+EMIS1atLhcltG4l156yTh11apVM84ZB21yRg46ZZkzZzazm3B2Gj9Mr0anjtk3uE/OBLJ27VoT9WOaNg4A9VO3bl0zE0muXLnMe87WoX3sFEVRFEVREgEduIceesg8HuWUcYULF75m+Z9++gm1atUy5ekA+h0wP5wujo9oGeVj/zhG7R577DEzXdv69etRpkyZxJyW9rFTFEVRFEW5Ufz959jX7XpOHeG8tOSFF164yqkjnByBTh/7yPnn8PXPMf/jjz8m2P/uemi6E0VRFEVRlETAR6GEM1Elhh07dlyeujQhOCjC78j5y/JRbtq0afHVV1+ZwRB0/jjI4tChQ4k6pjp2iqIoiqIoiUxhRrJly5aY4jh37px5veuuu1zL5MyZ07yePXvWvN5///1YvHgxateujYMHD6J///545ZVXkDdvXtSpU+eyc+mGOnaKoiiKoiiJwJ+6jKNaE0OWLFnMK0fLusEBEoH79kcE2c+OI3Bnz56Njz76yDh2fLTLPnvXOr46doqiKIqiKImgZMmS5pWjYRNDkSJFzOuWLVsS/JxROo6YDSx7pWPIKF3Hjh2xbds2MxKXUTyOqA3EnyqFqGOnKIqiKIqSCOrXr29eJ0+ebFKWXA86Zf40JEeOHLnqcz5mZf45jopl8uJrwZx2pUuXNutX9rdj0mNy4cIFdewURVEURVESQ7ly5cyI2KioKJNDjulPAmEy4m+++ebyeyYmZrJhOm/MZxf4SJaPVb/44guz/vHHH1+Our311lsYO3Yszp8/H7Rv9rubP3++WX/ggQeCPuOsFGTRokWax05RFEVRFCWxsN/bE088gV9++eXyPK133nmneaTK/nIJzTzBqccOHDhgUpvwcS4HYXA7adiwIb7//vvLjh0HTzCHXZo0aUxKFfa9437904ZxIMWIESOCzonvOYMF0QTFYQpz1/hHyCiKoiiKkvRkzZo1qH9aYrl06ZKZK/aHH37Apk2bTEQud+7cJqLHGSPq1asXVJ4zSXTq1MnkwePsE3Tw6MC98cYb+Ne//hV0Dj///LMpt2TJEuMscr557rtYsWImFQr3ndA59+zZE4MHD1bHLlyhN3/bbbel9GkoiqIoiljOnDmDv/3tb5CERuwsjtjR+WNiQ3r0iW2YfNZ/ZZ+ApCgbqn2Hk8ZQ1ceNagwHu3hF442UDaXGcKkP6Rr1ehOedgmlHbPeZMQunEmT0iegJAwbWmIdGZZLbNmIiIiQlA31vsNBYyjr40Y0hpNdpGu80fMIlcZwqQ+vaNTrTXjaJZR2lISmO/EYfD4firKh3nc4nEco6yOU+1WNyVcfNtpFNd4aer1JvrYXyrYqCX0UK6AfnsQ+An5UowzUjjKQbkfp+ohqlI9G7CyGo2o+//xz8yoV1SgDtaMMpNtRuj6iGuWjETtFURRFURQhaMROURRFURRFCOrYKYqiKIqiCEEdO0VRFEVRFCGoY6coiqIoiiIEdewspEOHDiYDNzNm33XXXahfvz62b98OSfTt2xdlypS5nGCyQoUKmDVrFiTblEmpW7VqBUm0bdvW6ApccuXKBUkcPHjQTMqdPXt2ZMqUycz/uHr1akiBE5xfaUMuknKKxcTE4LPPPkPBggWRMWNG3HPPPfjyyy8RFxcHSXA2I15jOEk9dVasWPGGZn4INxYvXownn3wSefLkMW1y8uTJV83gxGsQP6fe6tWrY/PmzZCOOnYWsmjRInNRXbFiBebNm2cuSrVr18Zff/0FKeTNmxcdO3bEqlWrzPKPf/wDTz/9tMh/Sl5YBwwYYBxZiZQsWRKHDx++vGzcuBFS+OOPP1CpUiWkTZvW/PDYsmULunbtimzZskFS+wy0H6855IUXXoAUODl7v3790Lt3b2zduhWdO3dGly5d0KtXL0iiadOmxn4jRoww/4e8b9SsWdP8OLER3vPuu+8+Y7eE6Ny5M7p162Y+Zzvmj8patWpdd7pO6/Ep1nPs2DEfTblo0SKfZG6//XbfoEGDfJI4e/asr3Dhwr558+b5qlWr5nv33Xd9kvj888999913n08qH330ka9y5co+L8E2WqhQIV9cXJxPCk888YTv9ddfD9r27LPP+l555RWfFM6fP++LiIjwTZ8+PWg7/z8//fRTn+3wHjhp0qTL79k+c+XK5evYsePlbVFRUb7bbrvN169fP59kNGInAGZJJ3fccQckEhsbizFjxphfZ3wkKwlGXp944gnzq1kqO3fuNI9C+Jjrn//8J3bv3g0pTJ06FQ8++KCJXrFbRNmyZTFw4EBI5eLFixg5ciRef/11UROnV65cGfPnz8eOHTvM+/Xr12Pp0qV4/PHHIQU+2eG1NEOGDEHb+YiSWqWxZ88eHDlyxEQlA5MzV6tWDcuXL4dk0qT0CSi3Bn+otG7d2lyYSpUqJao6+aiAjlxUVBSyZMmCSZMmoUSJEpACndU1a9ZY3cflejz88MMYPnw4ihQpgqNHj6Jdu3amXw8fqbNPmu3QSWV/UP4PfvLJJ/j111/RsmVLcwN59dVXIQ32YTp9+jQaN24MSXz00UfmB3KxYsXMRPN0gNq3b4+XXnoJUmCfbF5Pv/rqKxQvXhw5c+bE6NGjsXLlShQuXBjSOHLkiHmlzkD4ft++fZCMOnaW8/bbb2PDhg0if3EVLVoU69atMzeSCRMmoFGjRqZ/oQTnLjIyEu+++y7mzp171S9oSdStW/fyeunSpc2NpVChQvj++++NM2Q77FzPiN3XX39t3jNiR6eVzp5Ex27w4MHGpozASmLs2LEmEvnDDz+YPqG87nCQAXXyuiMF9q1jtPXvf/+7cWAfeOABvPzyy+YHplRSXRFZZjBEUrQ5IdSxs5h33nnHPAriyCAONpBGunTpcO+995p13jwZ2fr222/Rv39/2A5HTR47dgzlypW7vI1RAtqSHX2jo6PNhVcamTNnNg4eH89KIHfu3Ff90GA0hD9EpMEox08//YSJEydCGh9++CE+/vhj01WAsI1SL0erS3Ls+KOKP47ZreXPP/807bdBgwamm4Q0cv1v9D0jd9Tph9fdK6N40tA+dhbCXxyM1PECu2DBApH/lG666fBI4NFHHzWPmhkZ8C90Xv/1r3+ZdYlOHaH9OOow8EJrMxwRe2WqIfbTYjoJaQwdOtT0I2SfUGmcP38eqVMH3w75Pygt3UngDyz+D3JU95w5c0zGAWnwvkjnzj+K299HlI4tu4NIRiN2lna45yODKVOmmH4T/r4Et912m+kIKwH2V+Ijn3z58pmh6eyPtnDhQsyePRsSoN2u7BPJiy37nUnqK/nBBx+YPFN33323+aXMPnaMFEiJgrz33nvmJsFHsS+++KLpY8fUNVwkQQeHjh3tliaNvNsG2yj71LGd8lHs2rVrTZoMPraUBJ04/kBmN5fff//dRCq5/tprr8FGzp07Z3QEDphYt26dGUhIW/JxOv832YeQC9eZa5KPn0WT0sNylRuHZktoGTp0qJjqZOqB/Pnz+9KlS+fLkSOH79FHH/XNnTvXJxmJ6U4aNGjgy507ty9t2rS+PHnymBQSmzdv9kli2rRpvlKlSvnSp0/vK1asmG/AgAE+acyZM8dcY7Zv3+6TyJ9//mn+9+6++25fhgwZfPfcc49JARIdHe2TxNixY402XleZCqRFixa+06dP+2zl559/TvBe2KhRo8spT5hyiVr5/1m1alXfxo0bfdJJxT8p7VwqiqIoiqIot472sVMURVEURRGCOnaKoiiKoihCUMdOURRFURRFCOrYKYqiKIqiCEEdO0VRFEVRFCGoY6coiqIoiiIEdewURVEURVGEoI6doiiKoiiKENSxUxRFURRFEYI6doqiKIqiKEJQx05RFEVRFEUI6tgpiqIoiqJABv8Pw9aTbLECzF0AAAAASUVORK5CYII=", + "image/png": "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", "text/plain": [ "Graphics object consisting of 1 graphics primitive" ] }, - "execution_count": 22, + "execution_count": 23, "metadata": {}, "output_type": "execute_result" } @@ -1162,7 +1352,7 @@ }, { "cell_type": "markdown", - "id": "1ae76060", + "id": "a360b077", "metadata": {}, "source": [ "And we can check the formula against Gambit.\n", @@ -1172,23 +1362,20 @@ { "cell_type": "code", "execution_count": 24, - "id": "5b711f6b", + "id": "0ec6a91b", "metadata": { "execution": { - "iopub.execute_input": "2026-08-18T22:21:50.780896Z", - "iopub.status.busy": "2026-08-18T22:21:50.780787Z", - "iopub.status.idle": "2026-08-18T22:21:50.783635Z", - "shell.execute_reply": "2026-08-18T22:21:50.783278Z" + "iopub.execute_input": "2026-08-23T17:12:28.808254Z", + "iopub.status.busy": "2026-08-23T17:12:28.808102Z", + "iopub.status.idle": "2026-08-23T17:12:28.813189Z", + "shell.execute_reply": "2026-08-23T17:12:28.812544Z" } }, "outputs": [ { "data": { "text/plain": [ - "[[(0.0, 1.0), (1.0, 0.0)],\n", - " [(0.39999999999999997, 0.6000000000000001),\n", - " (0.39999999999999997, 0.6000000000000001)],\n", - " [(1.0, 0.0), (0.0, 1.0)]]" + "[[(0, 1), (1, 0)], [(2/5, 3/5), (2/5, 3/5)], [(1, 0), (0, 1)]]" ] }, "execution_count": 24, @@ -1204,64 +1391,66 @@ }, { "cell_type": "markdown", - "id": "6ec1ea0f", + "id": "638113c9", "metadata": {}, "source": [ - "The middle equilibrium puts weight `0.39999999999999997` on Hawk. That is Gambit's floating point rendering of a number the formula gives us exactly:" + "The middle equilibrium puts weight `2/5` on Hawk, and the formula gives the same value exactly. The two answers can be compared directly rather than up to a floating point tolerance." ] }, { "cell_type": "code", - "execution_count": 23, - "id": "40eff1c4", + "execution_count": 25, + "id": "cddb87cf", "metadata": { "execution": { - "iopub.execute_input": "2026-08-18T22:21:50.784600Z", - "iopub.status.busy": "2026-08-18T22:21:50.784499Z", - "iopub.status.idle": "2026-08-18T22:21:50.786672Z", - "shell.execute_reply": "2026-08-18T22:21:50.786358Z" + "iopub.execute_input": "2026-08-23T17:12:28.814484Z", + "iopub.status.busy": "2026-08-23T17:12:28.814335Z", + "iopub.status.idle": "2026-08-23T17:12:28.818995Z", + "shell.execute_reply": "2026-08-23T17:12:28.818382Z" } }, "outputs": [ { "data": { "text/plain": [ - "2/5" + "True" ] }, - "execution_count": 23, + "execution_count": 25, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "p_star.subs(v=2, c=5)" + "p_hat = numeric.obtain_nash(algorithm=\"enummixed\")[1][0][0]\n", + "\n", + "QQ(p_star.subs(v=2, c=5)) == p_hat" ] }, { "cell_type": "markdown", - "id": "b1671913", + "id": "d5c499a1", "metadata": {}, "source": [ "## Case study 2: from a graph to a game\n", "\n", "The second thing Sage brings is its library of mathematical objects. Here we turn a *graph* into a game and let Gambit analyse it.\n", "\n", - "In the **max cut game**, every vertex of a graph is a player choosing one of two sides. A player's actions are either `0` or `1`, representing the side they choose, and the payoff is the number of its incident edges that end up cut, that is, joining vertices on opposite sides. A pure Nash equilibrium is exactly a cut that no single vertex can improve by switching sides, thus a *locally* optimal cut.\n", + "In the **max cut game**, every vertex of a graph is a player choosing one of two sides. A player's payoff is the number of its incident edges that end up cut, that is, joining vertices on opposite sides. A pure Nash equilibrium is exactly a cut that no single vertex can improve by switching sides — a *locally* optimal cut.\n", "\n", "We use the house graph: five vertices, six edges." ] }, { "cell_type": "code", - "execution_count": 27, - "id": "00206d88", + "execution_count": 26, + "id": "adcb2c9d", "metadata": { "execution": { - "iopub.execute_input": "2026-08-18T22:21:50.787715Z", - "iopub.status.busy": "2026-08-18T22:21:50.787633Z", - "iopub.status.idle": "2026-08-18T22:21:50.892074Z", - "shell.execute_reply": "2026-08-18T22:21:50.891666Z" + "iopub.execute_input": "2026-08-23T17:12:28.820208Z", + "iopub.status.busy": "2026-08-23T17:12:28.820079Z", + "iopub.status.idle": "2026-08-23T17:12:28.995407Z", + "shell.execute_reply": "2026-08-23T17:12:28.994866Z" } }, "outputs": [ @@ -1272,7 +1461,7 @@ "Graphics object consisting of 12 graphics primitives" ] }, - "execution_count": 27, + "execution_count": 26, "metadata": {}, "output_type": "execute_result" } @@ -1284,7 +1473,7 @@ }, { "cell_type": "markdown", - "id": "6a1a0d3c", + "id": "3e04602e", "metadata": {}, "source": [ "Building the game is a matter of filling in one payoff array per vertex.\n", @@ -1293,14 +1482,14 @@ }, { "cell_type": "code", - "execution_count": 30, - "id": "81e592cd", + "execution_count": 27, + "id": "bb2dea49", "metadata": { "execution": { - "iopub.execute_input": "2026-08-18T22:21:50.893203Z", - "iopub.status.busy": "2026-08-18T22:21:50.893115Z", - "iopub.status.idle": "2026-08-18T22:21:50.896394Z", - "shell.execute_reply": "2026-08-18T22:21:50.896045Z" + "iopub.execute_input": "2026-08-23T17:12:28.996943Z", + "iopub.status.busy": "2026-08-23T17:12:28.996753Z", + "iopub.status.idle": "2026-08-23T17:12:29.003034Z", + "shell.execute_reply": "2026-08-23T17:12:29.002478Z" } }, "outputs": [ @@ -1310,7 +1499,7 @@ "5" ] }, - "execution_count": 30, + "execution_count": 27, "metadata": {}, "output_type": "execute_result" } @@ -1334,22 +1523,22 @@ }, { "cell_type": "markdown", - "id": "a360b077", + "id": "6a4ac7b2", "metadata": {}, "source": [ - "For five players, we use Gambit's `'enumpure'` to enumerate the pure equilibria." + "Five players, so this is squarely in Gambit's territory. `'enumpure'` enumerates the pure equilibria." ] }, { "cell_type": "code", - "execution_count": 31, - "id": "0ec6a91b", + "execution_count": 28, + "id": "21c02cd5", "metadata": { "execution": { - "iopub.execute_input": "2026-08-18T22:21:50.897383Z", - "iopub.status.busy": "2026-08-18T22:21:50.897306Z", - "iopub.status.idle": "2026-08-18T22:21:50.900154Z", - "shell.execute_reply": "2026-08-18T22:21:50.899764Z" + "iopub.execute_input": "2026-08-23T17:12:29.004413Z", + "iopub.status.busy": "2026-08-23T17:12:29.004257Z", + "iopub.status.idle": "2026-08-23T17:12:29.009042Z", + "shell.execute_reply": "2026-08-23T17:12:29.008505Z" } }, "outputs": [ @@ -1359,7 +1548,7 @@ "6" ] }, - "execution_count": 31, + "execution_count": 28, "metadata": {}, "output_type": "execute_result" } @@ -1371,22 +1560,23 @@ }, { "cell_type": "markdown", - "id": "638113c9", + "id": "a2e32102", "metadata": {}, "source": [ - "Each equilibrium is a cut, so we read the profiles back and count how many edges each one cuts." + "Each equilibrium is a cut, so we read the profiles back and count how many edges each one cuts.\n", + "The probabilities are exact, so a pure strategy is the integer `0` or `1` and needs no rounding." ] }, { "cell_type": "code", - "execution_count": 34, - "id": "cddb87cf", + "execution_count": 29, + "id": "d4e3fcc5", "metadata": { "execution": { - "iopub.execute_input": "2026-08-18T22:21:50.901105Z", - "iopub.status.busy": "2026-08-18T22:21:50.901021Z", - "iopub.status.idle": "2026-08-18T22:21:50.903833Z", - "shell.execute_reply": "2026-08-18T22:21:50.903489Z" + "iopub.execute_input": "2026-08-23T17:12:29.010232Z", + "iopub.status.busy": "2026-08-23T17:12:29.010110Z", + "iopub.status.idle": "2026-08-23T17:12:29.013389Z", + "shell.execute_reply": "2026-08-23T17:12:29.012939Z" } }, "outputs": [ @@ -1408,21 +1598,21 @@ " return sum(1 for (u, w) in G.edges(labels=False) if profile[u] != profile[w])\n", "\n", "\n", - "profiles = sorted({tuple(int(round(s[1])) for s in eq) for eq in equilibria})\n", + "profiles = sorted({tuple(int(s[1]) for s in eq) for eq in equilibria})\n", "for profile in profiles:\n", " print(f\"{profile} cuts {cut_size(profile)} edges\")" ] }, { "cell_type": "code", - "execution_count": 27, - "id": "d5c499a1", + "execution_count": 30, + "id": "034dccb2", "metadata": { "execution": { - "iopub.execute_input": "2026-08-18T22:21:50.904771Z", - "iopub.status.busy": "2026-08-18T22:21:50.904693Z", - "iopub.status.idle": "2026-08-18T22:21:50.958370Z", - "shell.execute_reply": "2026-08-18T22:21:50.958014Z" + "iopub.execute_input": "2026-08-23T17:12:29.014483Z", + "iopub.status.busy": "2026-08-23T17:12:29.014370Z", + "iopub.status.idle": "2026-08-23T17:12:29.102185Z", + "shell.execute_reply": "2026-08-23T17:12:29.101652Z" } }, "outputs": [ @@ -1432,7 +1622,7 @@ "5" ] }, - "execution_count": 27, + "execution_count": 30, "metadata": {}, "output_type": "execute_result" } @@ -1443,13 +1633,13 @@ }, { "cell_type": "markdown", - "id": "adcb2c9d", + "id": "215df832", "metadata": {}, "source": [ "Four of the six equilibria achieve the optimum of five cut edges, but two of them get stuck at four.\n", "Those are the locally stable cuts that are not globally optimal, and the ratio $4/5$ is this game's price of anarchy.\n", "\n", - "Gambit found the equilibria, whereas with Sage we could certify which of them were actually the global maximum, demonstrsting the symbiosis between the two libraries.\n", + "Gambit found the equilibria; Sage certified which of them were actually good. Neither library could have produced that sentence alone.\n", "\n", "## Summary\n", "\n", @@ -1457,11 +1647,13 @@ "|---|---|\n", "| Gambit game to Sage | `NormalFormGame(game)` |\n", "| Sage game to Gambit | `game._gambit_()` |\n", - "| Read and write `.nfg` | `game.load_nfg(path)`, `game.save_nfg(path)` |\n", - "| Browse and load catalog games | `game.load_from_gambit_catalog()` |\n", + "| Read and write `.nfg` | `NormalFormGame.load_nfg(path)`, `game.save_nfg(path)` |\n", + "| Browse the Gambit catalog | `NormalFormGame.gambit_catalog_games()` |\n", + "| Load a catalog game | `NormalFormGame.load_from_gambit_catalog(slug)` |\n", "| Solve with Sage (exact, two players) | `game.obtain_nash(algorithm='enumeration')` |\n", "| Solve with Gambit | `game.obtain_nash(algorithm='LCP')` and friends |\n", "| Solve with more than two players | `game.obtain_nash(algorithm='enumpoly')` |\n", + "| Ask for floating point answers | `game.obtain_nash(rational=False)` |\n", "| Draw the payoff bimatrix | `game.plot()` |\n", "\n", "For games in extensive form — trees, information sets, and chance moves — see the companion tutorial, [Using Gambit with SageMath: extensive form games](sagemath_extensive_form.ipynb).\n", @@ -1471,12 +1663,6 @@ "- [SageMath game theory reference](https://doc.sagemath.org/html/en/reference/game_theory/index.html)\n", "- [PyGambit API documentation](https://gambitproject.readthedocs.io/en/latest/pygambit.api.html)" ] - }, - { - "cell_type": "markdown", - "id": "3e04602e", - "metadata": {}, - "source": [] } ], "metadata": {