---
name: bingocalculator-probability
description: Calculate bingo probabilities and 1-in-N odds with the Bingocalculator MCP service for 75-ball 5x5 cards without a free space and non-repeating three-board Variant. Use for first completion of lines or a fixed pattern within a call interval. Clarify ambiguous rules before calling the service.
metadata:
  version: "1.0.0"
---

# Bingocalculator probability

Use `CalculateProbability` from the MCP server at **https://bingocalculator.com/mcp** for supported bingo probability requests. Answer in the user's language.

## Connect and choose the tool

The service uses **Streamable HTTP** and requires no API key. Use the client's connected MCP tool; its client-side name may have a prefix. Discover the tool and check its current input schema. The schema and this skill must agree for the requested calculation. If they conflict, explain the mismatch before proceeding.

If the server is not connected, help the user add the endpoint in their MCP-capable client. Installing this skill and connecting an MCP server are separate client capabilities; the dependency metadata is a hint, not a guarantee of automatic setup.

For a numerical answer, obtain a successful server result for the requested arguments. Do not substitute a local formula, simulation, recalled example, or guessed value for that call. If the service cannot be reached, report that the result is unavailable. Conceptual explanations of the rules do not need a server call.

## Resolve the request

Reuse details already established in the conversation. Ask only for missing or ambiguous information that changes the event being calculated. Do not silently choose a card type, winning requirement, or final call count.

### Card type

| User's card | `ticketType` |
| --- | --- |
| One 5x5 card, 75-ball, no free space | `FiveByFive75NoFree` |
| Variant: three 5x5 boards, 75 distinct numbers across all three, no free spaces | `VariantThreeUp75NoFree` |

Variant uses one shared draw. The event occurs when the first of its three boards satisfies the whole requirement. Two required rows must be on the same board. Do not multiply a single-board probability by three or treat the boards as independent. Three arbitrary cards with overlapping numbers do not meet the Variant definition.

Free spaces, 90-ball cards, other number pools, and repeated numbers within Variant are outside this version. Explain the limitation instead of changing the user's rules to fit a supported type.

### Winning requirement

| Required event | `winningRequirement` |
| --- | --- |
| First line in any allowed direction: horizontal, vertical, or either full diagonal | `OneLineAnyDirection` |
| First horizontal row | `OneHorizontalLine` |
| At least two horizontal rows on one board | `TwoHorizontalLines` |
| At least three horizontal rows on one board | `ThreeHorizontalLines` |
| At least four horizontal rows on one board | `FourHorizontalLines` |
| All five horizontal rows on one board | `FiveHorizontalLines` |
| All numbers in one predetermined pattern | `FixedPattern` |

“One line” alone may need clarification about direction. Multiple-line requirements here are horizontal only. A call completing several allowed lines at once still counts as a single first-completion event.

For `FixedPattern`, supply `requiredNumbers`: the number of distinct, predetermined numbered cells, from **1 to 25**, per board. Every one of those numbers must be called; extra marks are allowed. A complete X on a 5x5 card without a free space has nine distinct cells, including its centre once. Its input is `requiredNumbers: 9`, **not any nine hits**. Coordinates and actual numbers are unnecessary for this model.

Do not add rotated, mirrored, or alternative patterns. The pattern count describes one fixed set of required cells. It cannot replace “any line”, “any nine hits”, or several alternative patterns. `FourCorners` is not an enum value in this version; do not invent it. If the user explicitly describes a single fixed set of four corner cells, that event can be represented as `FixedPattern` with `requiredNumbers: 4`; state that mapping.

Omit `requiredNumbers` for line requirements (or send `null`). Do not use `requiredNumbers` to set the number of rows.

### Call interval: first completion

`callsTo` is required and has **no default**. `callsFrom` defaults to **0**. Both are integers and must satisfy `0 <= callsFrom <= callsTo <= 75`.

The result is the probability that the requirement is met **for the first time** within the inclusive interval, measured from the start of the draw:

| Meaning | Arguments |
| --- | --- |
| Completed by call 12, including earlier calls | `callsFrom: 0, callsTo: 12` |
| First completed on exactly call 12 | `callsFrom: 12, callsTo: 12` |
| First completed on call 10, 11, or 12 | `callsFrom: 10, callsTo: 12` |

“After 12 calls” can mean “completed by then” or “first completed on that call”. Clarify if the conversation does not resolve it. “By call 12” and “first on call 12” are already clear.

A nonzero start does **not** condition on having failed before that point. For Variant, if one board qualifies on call 10 and another on call 12, the Variant first qualifies on call 10 and is excluded from the interval 12–12.

The model assumes equally likely draws without replacement from the full pool. It does not accept observed calls, existing marks, or a condition such as “given no bingo by call 20”. It calculates completion of a requirement, not winning ahead of opponents, payout odds, or return to player.

## Call, check, and explain

1. Send the agreed arguments to `CalculateProbability`. Use the exact enum strings above and JSON integers, not numeric strings.
2. Check for a protocol error and for `isError: true`. HTTP 200 alone does not establish success. Explain validation errors, correct arguments only when the user's intent is clear, and do not turn errors into zero probability. For a transient connection failure, make at most one retry; do not repeatedly retry unchanged invalid arguments.
3. Read `structuredContent`. If the client exposes only text content, parse the returned JSON object. Require both `probability` (a finite number from 0 to 1) and `odds` (a finite number at least 1 for a positive probability, or `null` when probability is zero). If the result is missing or inconsistent, report the problem rather than repairing or fabricating it.
4. Report the **returned** `odds` as **1 in N**, and the returned `probability` as a probability or percentage. Retain the returned precision unless the user asks for rounding. If a shortened display is requested, label it approximate. Do not recompute one field from the other: they are independently converted from exact fractions to finite-precision numbers.
5. Briefly name the card type, requirement, and first-completion interval so the user can check the interpretation. Attribute the result to Bingocalculator and provide the arguments or raw result when useful for reproducing it.

`probability: 0, odds: null` is a valid impossible event. Say it is impossible within the requested interval; do not say “1 in 0”. `probability: 1, odds: 1` means certain under the model. “1 in N” is a probability, not a guarantee that exactly every Nth ticket qualifies, and not a payout multiplier.

Use a consistent unit for either card type: one instance of the selected ticket type. For Variant, keep the label “Variant”; do not divide or multiply the result by three or switch to “packs of three tickets”.

## Examples of tool arguments

These are parameter examples, not substitutes for fresh tool results.

**One predetermined number, by call 12, one 5x5 card without a free space:**

```json
{"ticketType":"FiveByFive75NoFree","winningRequirement":"FixedPattern","callsTo":12,"requiredNumbers":1}
```

**Two horizontal rows on the same Variant board, first completed on calls 20 through 30:**

```json
{"ticketType":"VariantThreeUp75NoFree","winningRequirement":"TwoHorizontalLines","callsFrom":20,"callsTo":30}
```

**A fixed X on one 5x5 card without a free space, first completed on exactly call 30:**

```json
{"ticketType":"FiveByFive75NoFree","winningRequirement":"FixedPattern","callsFrom":30,"callsTo":30,"requiredNumbers":9}
```

If a user asks “What are my bingo odds?”, obtain the card type, requirement, and call limit first. If they specify a supported card and requirement but omit the interval start, use 0. Do not ask for actual card numbers when the supported model only needs the card type and pattern count.