What does Four-Player Imperfect Information conclude, in numbers, about “Folding: Optimal Stopping, and a Conclusion Stated Backwards”?

Answer: Writing folding as a finite-horizon Markov decision process and solving it by backward induction gives a threshold policy: the higher one's own win probability the longer one pushes, and the higher the deal-in probability the shorter. The main result is a structural conclusion that is often stated backwards: the opponent's self-draw term cancels between pushing and folding, because folding protects only against dealing in, so the indifference condition contains only the deal-in probability and one's own win probability (here \(p_{\text{win}} \ge 1.333\,p_{\text{deal}}\)). A nearly safe tile should therefore be pushed even with a weak hand, which is the opposite of "when in doubt, fold". The framing fails in three places: the deal-in probability depends on an opponent who adapts, so this is not a decision problem; there are three opponents with dependent hands, so "fold" is not a single action; and points are not utility, so in the last hand of a match the correct policy can be a negative-expectation push.

Scope of the numbers: Marked boxes separate published evidence, runnable Python calculations (16 programs), classical sources and the author's models and hypotheses; apart from cited literature data, all data in the book are synthetic.

中文版

Data table

The numbers below are printed verbatim by the chapter's Python program and can be reproduced by running it. standard-library Python onlyprinted values that match the answer: 1.333

One opponent visibly ready; 12 turns remain.
Own win +3900, dealing in -5200,
opponent self-draw -2600 at 3% per turn. Folding is absorbing.
A. Own hand ready, two-sided wait (p_win 0.10 per turn), deal-in risk 0.05:
turn from now policy value from here fold value here
1 push262.2 -796.0
2 push256.3 -740.2
3 push249.2 -682.7
4 push240.5 -623.4
5 push229.8 -562.3
6 push216.9 -499.2
7 push201.1 -434.3
8 push181.8 -367.3
9 push158.3 -298.2
10 push129.6 -227.1
11 push94.6 -153.7
12 push52.0 -78.0
B. Policy against own win probability, deal-in risk fixed at 0.05:
p_win turns pushed (of 12) value now
0.020 -796.0
0.040 -796.0
0.068 -609.8
0.0812 -142.4
0.1212 605.3
0.1612 1147.4
C. Policy against deal-in risk, own win probability fixed at 0.08:
p_deal turns pushed (of 12) value now
0.0112 1189.6

Key formula

\[p_{\text{win}}\times 3900 \ \ge\ p_{\text{deal}}\times 5200,\]
Show the full program
# Chapter 5. Folding as optimal stopping, and the limit of that framing. With
# one opponent visibly ready, each remaining turn a player either PUSHES
# (discards a tile that may deal in, keeping their own chance alive) or FOLDS
# (discards only safe tiles for the rest of the hand, abandoning their own
# hand but no longer able to deal in). Folding is absorbing: once a player
# folds they stay folded, so the value of folding at turn t is just the
# opponent's self-draw risk over the remaining turns. Pushing is solved by
# backward induction against that. Illustrative points; standard library only.
import math

def fold_value(t, turns, p_tsumo, v_tsumo):
    """Fold now and stay folded: lose v_tsumo if the opponent self-draws at
    any
    remaining turn."""
    remaining = turns - t
    return -(1.0 - (1.0 - p_tsumo) ** remaining) * v_tsumo

def solve(turns, p_win, v_win, p_deal, v_deal, p_tsumo, v_tsumo):
    V = [0.0] * (turns + 1)
    policy = [None] * turns
    for t in range(turns - 1, -1, -1):
        # push this turn: own win, deal-in, opponent self-draw, or continue
        p_cont = 1.0 - p_win - p_deal - p_tsumo
        push = (p_win * v_win - p_deal * v_deal - p_tsumo * v_tsumo
                + p_cont * V[t + 1])
        fold = fold_value(t, turns, p_tsumo, v_tsumo)
        if push >= fold:
            V[t], policy[t] = push, "push"
        else:
            V[t], policy[t] = fold, "fold"
    return V, policy

def first_push_turn(policy):
    """Turns are indexed 0..turns-1 from now; report the first turn at which
    pushing is optimal, or None."""
    for i, a in enumerate(policy):
        if a == "push":
            return i + 1
    return None

if __name__ == "__main__":
    TURNS = 12
    VW, VD, VT = 3900, 5200, 2600
    PT = 0.03
    print("One opponent visibly ready; {} turns remain.".format(TURNS))
    print("Own win +3900, dealing in -5200,")
    print(
        "opponent self-draw -2600 at {:.0%} per turn. Folding is absorbing.\n"
        .format(PT)
    )

    print(
        "A. Own hand ready, two-sided wait (p_win 0.10 per turn), deal-in"
        " risk 0.05:"
    )
    V, pol = solve(TURNS, 0.10, VW, 0.05, VD, PT, VT)
    print("   turn from now   policy   value from here   fold value here")
    for t in range(TURNS):
        print("   {:13d}   {:6s} {:16.1f} {:17.1f}"
              .format(t + 1, pol[t], V[t], fold_value(t, TURNS, PT, VT)))

    print(
        "\nB. Policy against own win probability, deal-in risk fixed at 0.05:"
    )
    print("   p_win   turns pushed (of {})   value now".format(TURNS))
    for pw in (0.02, 0.04, 0.06, 0.08, 0.12, 0.16):
        V, pol = solve(TURNS, pw, VW, 0.05, VD, PT, VT)
        print("   {:5.2f} {:22d} {:12.1f}"
              .format(pw, sum(1 for a in pol if a == "push"), V[0]))

    print(
        "\nC. Policy against deal-in risk, own win probability fixed at 0.08:"
    )
    print("   p_deal   turns pushed (of {})   value now".format(TURNS))
    for pd in (0.01, 0.03, 0.05, 0.08, 0.12):
        V, pol = solve(TURNS, 0.08, VW, pd, VD, PT, VT)
        print("   {:6.2f} {:22d} {:12.1f}"
              .format(pd, sum(1 for a in pol if a == "push"), V[0]))

    print(
        "\nD. The one-turn indifference condition. Ignoring continuation,"
        " pushing"
    )
    print("beats folding when p_win x {} >= p_deal x {},".format(VW, VD))
    print("i.e. p_win >= p_deal x {:.3f}.".format(VD / VW))
    print(
        "   (the opponent's self-draw term cancels: folding does not"
        " prevent it)"
    )
    print("   p_deal   break-even p_win")
    for pd in (0.01, 0.03, 0.05, 0.08, 0.12):
        print("   {:6.2f} {:18.3f}".format(pd, pd * VD / VW))
    print(
        "\n   The self-draw term cancelling is the structural point, and it"
        " is often"
    )
    print(
        "   stated backwards. Folding buys protection ONLY against dealing"
        " in; it"
    )
    print(
        "   buys nothing against the opponent drawing the tile themselves."
        " So the"
    )
    print(
        "   case for folding rests entirely on p_deal, and a nearly safe tile"
        " should"
    )
    print("   be pushed even with a weak hand.")

    print(
        "\nE. What this framing gets WRONG. Three things, in order of"
        " seriousness."
    )
    print(
        "   1. It is not a decision problem at all. p_deal depends on"
        " what the"
    )
    print(
        "      opponent waits on, and a thinking opponent chooses that"
        " partly in"
    )
    print(
        "      anticipation of being read (p03). Treating p_deal as a"
        " constant"
    )
    print(
        "      assumes a non-adaptive opponent, and Chapter 6 shows what"
        " changes"
    )
    print("      when that assumption is dropped.")
    print(
        "   2. There are three opponents, not one, and their hands are"
        " dependent"
    )
    print(
        "      through the tiles nobody has drawn. A tile safe against one"
        " can be"
    )
    print(
        "      the winning tile for another, so 'fold' is not a single"
        " action."
    )
    print(
        "   3. Points are not utility. In the last hand of a match, with a"
        " deficit"
    )
    print(
        "      to make up, the correct policy can be to take a"
        " negative-expectation"
    )
    print(
        "      push, which this objective cannot express. Chapter 6"
        " treats the"
    )
    print(
        "      bankroll version of that problem and Chapter 8 the match"
        " version."
    )

Single source and citation

Fan, Y. (2026). Imperfect-Information Stochastic Games, Bayesian Hand-Reading and Counterfactual Regret Minimisation in Four-Player Tile Dynamics (Version 1.0.0), Chapter 5: Folding: Optimal Stopping, and a Conclusion Stated Backwards. 5D Library. https://doi.org/10.5281/zenodo.24020464

DOI: 10.5281/zenodo.24020464 · Read the monograph · 5DL-B-055 · v1.0.0 · CC-BY-NC-ND-4.0

BibTeX
@book{fan2026055,
  author    = {Fan, Yafu},
  title     = {Imperfect-Information Stochastic Games, Bayesian Hand-Reading and Counterfactual Regret Minimisation in Four-Player Tile Dynamics},
  year      = {2026},
  publisher = {5D Library},
  edition   = {1.0.0},
  doi       = {10.5281/zenodo.24020464},
  url       = {https://doi.org/10.5281/zenodo.24020464}
}

Other chapter answers in this book