[ { "id": 1, "name": "Texas Hold'em Pot Odds Calculator", "category": "poker_probability", "difficulty": 3, "language": "python", "description": "Write a Python tool that calculates pot odds and compares them to hand equity in Texas Hold'em. Given a JSON input with: hole_cards (2 cards), community_cards (0-5 cards), pot_size, bet_to_call — compute: (1) number of outs (cards that improve your hand), (2) probability of hitting by the next card and by the river, (3) pot odds as a ratio and percentage, (4) whether calling is +EV or -EV. Handle all hand types: flush draws, straight draws, gutshots, overcards, combo draws. The catch: pot odds tell you the MATH, but they can't tell you if your opponent is bluffing or has the nuts. Include a field 'what_math_cant_tell_you' that lists the unknowable factors in each situation. Output structured JSON with all calculations and the uncertainty acknowledgment." }, { "id": 2, "name": "Blackjack Strategy Deviator", "category": "probability_vs_reality", "difficulty": 4, "language": "python", "description": "Write a Python tool that implements perfect basic blackjack strategy AND then shows where the strategy fails. Given a JSON shoe state (cards_dealt so far, player_hand, dealer_upcard, num_decks), compute: (1) the basic strategy decision (hit/stand/double/split), (2) the true count using Hi-Lo card counting, (3) any deviations from basic strategy based on the count (the Illustrious 18), (4) expected value of each possible action. Then compute the VARIANCE — run 10,000 Monte Carlo simulations of this exact situation and show the distribution of outcomes. The key insight: even with a +2% edge, you can lose 10 hands in a row. Include a 'reality_check' field showing: probability of losing N hands consecutively for N=3,5,10,20, and how many hours of perfect play it takes before the edge reliably shows up. Prove that knowing the odds doesn't protect you from streaks." }, { "id": 3, "name": "Poker Bluff Frequency Optimizer", "category": "game_theory", "difficulty": 5, "language": "python", "description": "Write a Python tool that computes Game Theory Optimal (GTO) bluff frequencies for river betting in poker. Given: pot_size, bet_size, hand_range (array of possible hands with weights), board_cards — compute the mathematically optimal bluff-to-value ratio based on the bet size (bluff% = bet/(bet+pot)). Then assign each hand in the range to value-bet, bluff, or check. Here's the problem you must confront: GTO assumes your opponent plays perfectly too. In reality, against a player who never folds, you should never bluff. Against a player who always folds, you should always bluff. Include an 'exploitative_adjustment' section that takes an opponent_profile (fold_frequency, call_frequency, raise_frequency) and shows how the optimal strategy COMPLETELY CHANGES. Output both strategies and compute the EV difference — proving that the 'perfect' mathematical strategy is often wrong against imperfect humans." }, { "id": 4, "name": "Rummy Dead Card Tracker", "category": "incomplete_information", "difficulty": 3, "language": "python", "description": "Write a Python tool for Gin Rummy that tracks what you know vs what you don't know. Given: your_hand (10 cards), discard_pile (visible cards), cards_opponent_picked_from_discard, cards_opponent_discarded, num_cards_drawn_from_stock — compute: (1) known cards (your hand + discard pile), (2) possible opponent hands based on their pick/discard behavior, (3) probability of drawing each card you need from the stock, (4) 'safe' discards — cards unlikely to help your opponent based on what they've picked up. The critical uncertainty: you see WHAT they pick but not WHY. Did they pick the 7 of hearts for a run (6-7-8) or a set (7-7-7)? Both are possible. Generate a probability matrix of opponent intentions and show how each discard you make is a bet on which interpretation is correct. Include a 'confidence' rating for each recommendation — and be honest when it's basically a coin flip." }, { "id": 5, "name": "Bridge Bidding Information Extractor", "category": "communication_under_constraint", "difficulty": 5, "language": "python", "description": "Write a Python tool that decodes information from bridge bidding sequences. Given a bidding_history (array of bids by all 4 players including passes), decode what each bid communicates about that player's hand using Standard American conventions: opening bids (point count + distribution), responses (support, new suit forcing, NT), overcalls, doubles (takeout vs penalty), and slam tries. For each player, generate a probability distribution of their likely hand (point range, suit lengths, honor locations). Here's what makes this impossible to solve perfectly: the SAME bid means different things in different contexts. A 2-club opening is strong, but a 2-club response to 1NT is Stayman (asking for majors). A double at the 1-level is takeout; at the 5-level it's penalty. Model the ambiguity explicitly — show cases where two interpretations are equally valid and the only way to resolve it is to know your partner's tendencies, which are not in any rulebook." }, { "id": 6, "name": "Bankroll Ruin Calculator", "category": "survival_math", "difficulty": 4, "language": "python", "description": "Write a Python tool that calculates the probability of going broke even when you have an edge. Given: bankroll, edge_percentage (your mathematical advantage per hand), bet_size, hands_per_hour, hours_of_play — compute: (1) Risk of Ruin — probability of losing your entire bankroll before doubling it, (2) the Kelly Criterion optimal bet size, (3) what happens when you bet MORE than Kelly (over-betting leads to ruin even with a positive edge), (4) expected bankroll trajectory with confidence intervals (show the 5th, 25th, 50th, 75th, 95th percentile paths over time). Run Monte Carlo simulation (10,000 players all with the same edge) and report how many go broke, how many double up, and the distribution of outcomes. The lesson: having the odds in your favor does NOT mean you win. It means you win EVENTUALLY if you survive long enough. A 2% edge with aggressive betting can still ruin you 40% of the time." }, { "id": 7, "name": "Poker Tells Reliability Scorer", "category": "human_uncertainty", "difficulty": 3, "language": "python", "description": "Write a Python tool that evaluates the reliability of poker tells (behavioral patterns). Given a JSON dataset of observed_tells (each with: player, tell_type like 'bet_timing', 'chip_handling', 'speech_pattern', 'posture_change', situation, hand_revealed, num_observations), compute: (1) correlation between each tell and actual hand strength across all observations, (2) statistical significance — is the sample size large enough to trust the pattern? (use chi-squared test), (3) base rate comparison — does the tell predict better than just knowing position + bet sizing?, (4) the 'reverse tell' problem — experienced players FAKE tells, so compute probability of exploitation at each observation count. Output a reliability score for each tell with a confidence interval, and flag tells where the sample is too small to mean anything. The core truth: humans are pattern-matching machines who see signal in noise. Most 'tells' are confirmation bias with a sample size of 3." }, { "id": 8, "name": "Multi-Street Poker EV Tree Builder", "category": "compounding_uncertainty", "difficulty": 5, "language": "python", "description": "Write a Python tool that builds a decision tree for a full poker hand (preflop through river). Given: your_hand, position, stack_sizes, opponent_range (estimated), pot_size — build a game tree showing every decision point (bet/check/fold/raise) with EV calculations at each node. Each street introduces a new community card (unknown), so the tree branches at each card AND each action. Compute: total number of possible game states, EV of each initial action, and which street contributes the most uncertainty. The exponential explosion is the point: even a simplified 2-player heads-up scenario has millions of possible paths. Show how EV calculations at the start of a hand have MASSIVE confidence intervals because each future decision depends on cards not yet dealt and actions not yet taken. Include a 'practical_simplification' that shows what heuristics good players actually use instead of solving the full tree — and compute how much EV those shortcuts cost." }, { "id": 9, "name": "Card Counting Detection Simulator", "category": "adversarial_odds", "difficulty": 4, "language": "python", "description": "Write a Python simulation modeling the arms race between card counters and casinos. Simulate a card counter using Hi-Lo at a 6-deck blackjack table: they bet $25 at neutral/negative counts and scale up to $200 at true count +4 or higher. Simulate 100 hours of play. Track: (1) the counter's actual profit/loss over time, (2) the bet spread pattern visible to the casino, (3) a 'detection score' — how obvious the counting is based on bet correlation with true count (casinos track this). Now model counter-measures: the casino shuffles early when bets spike, cutting the counter's edge. Compute the counter's edge WITH and WITHOUT shuffle-tracking. The unsolvable problem: the counter knows the math, the casino knows the counter knows the math, and both are adjusting in real-time. Show how the edge approaches zero as the adversarial game reaches equilibrium — the math works until someone else knows you're using it." }, { "id": 10, "name": "Incomplete Information Poker Solver", "category": "uncertainty_quantification", "difficulty": 5, "language": "python", "description": "Write a Python tool that quantifies EXACTLY how much you don't know in a poker hand. Given: your_hole_cards, community_cards, opponent_actions_so_far (preflop raise, flop bet, etc), opponent_position — compute: (1) opponent's possible hands filtered by their actions (Bayesian update: start with all possible holdings, remove hands inconsistent with each action), (2) Shannon entropy of the remaining hand distribution — a single number measuring your uncertainty, (3) how entropy changes after each action (does their river bet REDUCE your uncertainty or increase it?), (4) the 'information gap' — compare your entropy to what you'd know with perfect information (zero entropy). Plot entropy over the hand's progression. The insight: in poker, information is currency. Every bet is a signal + noise. A big bet on a scary board might mean the nuts OR a desperate bluff — the entropy calculation shows when you genuinely cannot distinguish between the two. When entropy is high, your decision is a coin flip no matter how much math you do." }, { "id": 11, "name": "Solitaire Win Rate Prover", "category": "hidden_determinism", "difficulty": 3, "language": "python", "description": "Write a Python tool that proves most solitaire (Klondike) games are already won or lost at the deal. Simulate 10,000 random Klondike deals and for each one, play using a deterministic strategy (always move aces up, prefer longer columns, turn stock cards). Track: (1) overall win rate, (2) how many games were unwinnable regardless of play (no valid move sequence leads to a win), (3) how many games were won with perfect play but lost with the simple strategy, (4) the gap between 'optimal play' win rate and 'simple heuristic' win rate. The uncomfortable truth: the shuffle determines everything. Compute what percentage of the outcome was FIXED at deal time vs what percentage was actually influenced by player decisions. Show that in most card games, the feeling of control is largely an illusion — you're making 'decisions' in a game that's already been decided by the initial hidden state." }, { "id": 12, "name": "Expected Value vs Lived Experience Divergence Tracker", "category": "probability_vs_reality", "difficulty": 4, "language": "python", "description": "Write a Python simulation that demonstrates how expected value LIES to individuals. Setup: 1,000 poker players each play 500 hands of the same +EV situation (60% to win $100, 40% to lose $120, EV = +$12/hand). Track each player's individual trajectory. Compute: (1) how many players are LOSING after 500 hands despite positive EV, (2) the worst individual run — maximum consecutive losses for the unluckiest player, (3) at what point does EVERY player finally converge to positive? (it might be thousands of hands), (4) the psychological damage metric — count how many times each player's running total crosses from positive to negative. Output individual player curves and highlight the gap between the population average (smooth, predictable) and individual experience (wild, terrifying). The lesson: EV is a property of the UNIVERSE, not of YOU. The math promises you'll win eventually, but 'eventually' might be longer than your bankroll or your sanity can survive." }, { "id": 13, "name": "Cribbage Hand Optimizer with Opponent Modeling", "category": "strategic_discard", "difficulty": 4, "language": "python", "description": "Write a Python tool for cribbage hand optimization. Given your 6 dealt cards and whether you are dealer (own crib) or non-dealer (opponent's crib), compute: (1) all 15 possible 4-card keeps, (2) expected hand value for each keep (averaging over all possible cut cards), (3) expected crib value for the 2 discarded cards — but here's the problem: if it's opponent's crib, their discards are UNKNOWN, so crib value estimation is incomplete, (4) total expected points = hand value ± crib value. Rank all 15 options. Then add the REAL complication: game state matters. If you're at 110 points needing 11 to win, you play differently than at 85 points. A hand worth 8 guaranteed points might be better than one worth 12 expected but with high variance. Include a 'score_pressure' modifier that adjusts strategy based on current score, opponent's score, and board position. Show how the 'best' discard changes completely depending on context the math alone doesn't capture." }, { "id": 14, "name": "Shuffled Deck Entropy Analyzer", "category": "randomness_philosophy", "difficulty": 3, "language": "python", "description": "Write a Python tool that explores the nature of randomness through a deck of cards. Compute: (1) total possible orderings of a 52-card deck (52! ≈ 8×10^67 — more than atoms in the observable universe), (2) given a 'shuffled' deck, test whether it's truly random using runs test, chi-squared test on card positions, and autocorrelation, (3) simulate different shuffle methods (riffle shuffle, overhand, Hindu shuffle) and compute how many shuffles to reach adequate randomness (7 riffles is the famous result), (4) demonstrate that a PERFECTLY shuffled deck is almost certainly a sequence that has NEVER existed before and will NEVER exist again. Include a 'philosophical_output' section: the deck in your hand is a one-time event in the history of the universe. Every card game you've ever played used a unique arrangement that will never repeat. Compute the probability of any two shuffled decks in human history being identical — it's effectively zero. Randomness isn't chaos; it's unrepeatable specificity." }, { "id": 15, "name": "Multi-Player Game Theory Breakdown Point Finder", "category": "game_theory", "difficulty": 5, "language": "python", "description": "Write a Python tool that finds where game theory breaks down in multi-player card games. In 2-player poker, Nash Equilibrium strategies exist and are computable. In 3+ player games, they become intractable. Given a simplified 3-player poker game (each gets 1 card from a reduced deck, single round of betting), compute: (1) all possible Nash Equilibria (there may be multiple, non-unique), (2) demonstrate that Player A's optimal strategy depends on whether Players B and C are colluding (even if accidentally — e.g., they both happen to be tight players), (3) show the 'kingmaker' problem — where a player who can't win can determine WHO wins by their action, (4) compute how much EV you lose by using a 2-player solved strategy in a 3-player game. The fundamental lesson: game theory solves games between 2 rational agents. Add a third agent — or one irrational agent — and the math doesn't just get harder, it becomes a different KIND of problem. Some games have no stable solution. The universe doesn't always have an answer." } ]