Saddle point game theory calculator
In the matrix with rows (3, 1, 2), (4, 3, 5) and (2, 0, 4), the middle cell 3 is both its row's minimum and its column's maximum, so the game has a saddle point worth 3. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
A saddle point in a two-player zero-sum game is a cell of the payoff matrix that is simultaneously the minimum of its row and the maximum of its column. When such a cell exists, the row player can guarantee the game value by playing that row, the column player can hold the row player to that same value by playing that column, and the pair of pure strategies is a Nash equilibrium. Students, tutors, and exam writers need a fast check that maximin equals minimax, plus the list of every saddle cell, without mixing up row minima and column maxima. This saddle point game theory calculator accepts a rectangular payoff matrix for the row player, computes each row minimum and each column maximum, compares the maximin and minimax security levels, and reports whether a pure-strategy solution exists.
What a saddle point is and why maximin equals minimax
In a two-player zero-sum game the row player chooses a row of the payoff matrix and the column player chooses a column; the selected cell is the amount the column player pays the row player, or the row player's utility when the table is already written in that convention. A saddle point is a cell that is simultaneously the smallest entry in its row and the largest entry in its column.
The row player, who wants a large payoff, can guarantee at least the maximum among the row minima — the maximin value — by playing a row that attains that maximum. The column player, who wants that payoff to be small, can hold the outcome to at most the minimum among the column maxima — the minimax value — by playing a column that attains that minimum. Those two security levels always satisfy maximin less than or equal to minimax.
They are equal if and only if at least one saddle cell exists, and then every saddle cell carries that common number, which is the value of the game in pure strategies. The corresponding pair of actions is a Nash equilibrium: the row player cannot raise the payoff by switching rows against the column player's saddle column, and the column player cannot lower it by switching columns against the row player's saddle row.
Textbook three-by-three tables often have a unique saddle; some matrices have several cells that share the same value and form a combinatorial rectangle of equilibria; matching pennies has none, because maximin is negative one while minimax is positive one. Locating every saddle, or proving that none exists, is therefore the first fully algebraic step before anyone turns to mixed strategies.
Where a saddle point game theory calculator earns its keep
Introductory game theory courses assign saddle-point drills because maximin versus minimax is the first concrete equilibrium skill before mixed strategies and best-response graphs. Tutoring platforms and LMS auto-graders need a deterministic oracle that lists every saddle cell, or reports that none exist, instead of a spreadsheet that silently treats a near-tie as equality.
Instructors building practice banks want the same three-by-three textbook table students work by hand — row minima one, three, and zero, maximin three, column maxima four, three, and five, minimax three, saddle in row two column two — and they want matching pennies to come back as a clean no-saddle result that motivates the mixed-strategy lecture.
Pin the echoed matrix and the ordered saddle list in tests, keep entries finite and the shape inside the sixteen-by-sixteen limit, and you get reproducible pure-strategy solutions for homework, exam generators, and lightweight industrial-organization notes without standing up a full game-theory solver. Pair this capability with a mixed-strategy tool when maximin is strictly less than minimax; keep this one focused on the cell where a row minimum equals a column maximum.
What you can do with it
Homework and exam saddle-point checks
Students enter a payoff matrix and verify maximin, minimax, and every saddle cell against the textbook min-of-row / max-of-column method.
LMS and tutoring auto-grading
Score zero-sum pure-strategy items with a deterministic oracle that lists saddles or reports that none exist, without inventing mixed probabilities.
Small zero-sum models in notebooks
Solve a compact operations-research or industrial-organization payoff table in pure strategies before switching to a mixed-strategy solver.
FAQ
How do I find a saddle point in a game matrix?
Send payoff as a rectangular array of finite numbers (at least 2×2).
What if maximin is not equal to minimax?
Then the game has no saddle point in pure strategies.
Can a game have more than one saddle point?
Yes. Every saddle cell has the same payoff (the game value).
Are row and column indices zero-based or one-based?
One-based, matching textbook strategy numbers. The first row is row 1 and the first column is column 1. Validation messages use the same numbering.
What is the value of the game?
It is the payoff the row player can guarantee and the column player can hold them to when a saddle point exists. In that example, maximin and minimax both equal 3, so the game value in pure strategies is 3.
Related tools
For developers — API access
Everything on this page is available programmatically. This section is for teams who want to wire it into their own systems; everyone else can just use the tool above.
API endpoint
Prefer to automate it? One authenticated POST creates the task; the result comes back by webhook or a signed link. The same capability also runs here on the web, by email and from Telegram — and soon from our app too.
Call it from your stack
curl -X POST https://api.kit.forhosting.com/econ/saddle-point-game \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"payoff":[[3,1,2],[4,3,5],[2,0,4]]}'const res = await fetch("https://api.kit.forhosting.com/econ/saddle-point-game", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"payoff": [
[
3,
1,
2
],
[
4,
3,
5
],
[
2,
0,
4
]
]
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/econ/saddle-point-game",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"payoff": [
[
3,
1,
2
],
[
4,
3,
5
],
[
2,
0,
4
]
]
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/econ/saddle-point-game", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"payoff":[[3,1,2],[4,3,5],[2,0,4]]}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"payoff":[[3,1,2],[4,3,5],[2,0,4]]}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/econ/saddle-point-game", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"payoff": [
[
3,
1,
2
],
[
4,
3,
5
],
[
2,
0,
4
]
]
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "econ.saddle_point_game",
"status": "queued",
"_links": {
"result": "/tasks/tsk_…/result"
}
}The API is asynchronous: the call returns a task_id immediately and the result arrives by webhook. Polling is capped at 1 req/s per task.
Pricing
Published price — no tokens, no invented credits. A failed task is never charged.
Limits
max_rows | 16 |
max_cols | 16 |
Errors
| HTTP | Code | Meaning |
|---|---|---|
401 | unauthorized | Missing or invalid API key. |
402 | insufficient_balance | Your balance doesn't cover the task price. |
404 | unknown_type | That task type doesn't exist. |
429 | rate_limited | Too many requests. Use the webhook instead of polling. |
Technical notes
Input contract, the min-max scan, and how to read the result
Each inner array is one pure strategy of the row player; each position inside a row is the payoff against one pure strategy of the column player. Rows of unequal length fail because the matrix would not be rectangular. Non-finite cells, including NaN and infinities, fail with a message that names the one-based row and column. On a valid matrix the solver scans each row for its minimum and each column for its maximum, then sets maximin to the largest row minimum and minimax to the smallest column maximum. A cell is a saddle when its payoff equals both its row minimum and its column maximum; those cells are listed in row-major order with one-based row and column indices. Numbers are cleaned of minus-zero and floating-point dust so goldens stay stable across runtimes. POST a JSON body with one required field, payoff: a rectangular array of rows of finite numbers, at least two by two and at most sixteen by sixteen. Missing, empty, or non-array input fails with invalid_input naming payoff. When the list is non-empty, has_saddle_point is true, game_value equals the common saddle payoff, and row_strategy together with col_strategy report the first saddle as a convenient pure-strategy solution. When the list is empty, has_saddle_point is false and those three optional fields are omitted rather than set to null. The response also echoes rows, columns, payoff, row_mins, col_maxs, maximin, minimax, saddle_count, and a short formula string. Successful parse calls use the published $0.002 base price per item; validation failures are not billed.
Where a saddle point game theory calculator earns its keep
Operations-research notebooks that still solve small zero-sum models in pure strategies can call this endpoint instead of writing another min-max loop.
Technical questions
What does the saddle point game theory calculator cost?
The browser tool is free. API requests use prepaid KIT balance at $0.002 per successful call; invalid input is not billed.