What does Dissolving Entrenched Priors conclude, in numbers, about “Question Sequences as a Decision Process: a Simulated Optimum under Illustrative Parameters and Its Sensitivity”?

Answer: Chapter 6 casts the four moves as a Markov decision process: from the hardest start the expected value is 10.555, the full path survives two thousand perturbations in a share of 0.8270, and keeping the baseline policy costs a mean relative regret of only 0.0003, so the result is called a simulated optimum.

Scope of the numbers: Parameters are illustrative and all calculations are generated by the book's programs. Not counselling, no clinical service, not personalised business advice; examples concern only beliefs about goods, never political, religious or ethnic questions.

中文版

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: 0.0003, 0.8270

baseline path from D2, O=0: AAEEE
first action over 2,000 draws:
A1.0000
most frequent likely paths:
AAEEE0.8270
AAAAQ0.1365
AAAAE0.0360
AAQEE0.0005
relative regret of the baseline policy:
mean 0.0003 median 0.000095th pct 0.0019 max 0.0081
R first enters the policy at r_gain5.5
Show the full program
# Chapter 6. p62: how fragile is the "optimal" sequence?
# Same decision process as p61. Every probability and gain parameter is
# multiplied by an independent factor drawn from U(0.75, 1.25) (seeded,
# 2,000 draws; probabilities clipped to [0, 1]). For each draw: the
# optimal first action and most likely path from D=2, O=0, and the regret
# of keeping the baseline policy instead of re-optimizing. Last, the gain
# a thought experiment needs before it ever enters the policy.
import math
import random

H, PEN = 5, 5.0
W = (1.0, 0.5, 0.15)                 # discount weight by defence level
PAR = {"q_open": 0.5, "q_open_hi": 0.25, "q_def": 0.10,
       "a_down": 0.6, "e_def": 0.25, "e_leave": 0.15,
       "r_def": 0.15, "r_open": 0.3, "r_leave": 0.20,
       "e_gain": 6.0, "r_gain": 3.0, "q_gain": 1.0}
ACTS = "QAER"


def model(d, o, a, p):
    """Return (reward, [(prob, next_state)]), next_state None = left."""
    up = lambda x, k: min(2, x + k)
    if a == "Q":
        po = p["q_open"] if d <= 1 else p["q_open_hi"]
        pd = p["q_def"]
        out = [(po * pd, (up(d, 1), up(o, 1))),
               (po * (1 - pd), (d, up(o, 1))),
               ((1 - po) * pd, (up(d, 1), o)),
               ((1 - po) * (1 - pd), (d, o))]
        return p["q_gain"] * W[d], out
    if a == "A":
        pa = p["a_down"] if d > 0 else 0.0
        return 0.0, [(pa, (max(0, d - 1), o)), (1 - pa, (d, o))]
    if a == "E":
        pl = p["e_leave"] if d == 2 else 0.0
        pd = p["e_def"] * (1 - 0.3 * o)
        rew = (1 - pl) * p["e_gain"] * W[d] * (1 + 0.5 * o)
        return rew, [(pl, None), ((1 - pl) * pd, (up(d, 1), o)),
                     ((1 - pl) * (1 - pd), (d, o))]
    pl = p["r_leave"] if d == 2 else 0.0
    pd, po = p["r_def"], p["r_open"]
    rew = (1 - pl) * p["r_gain"] * o * W[d]
    out = [(pl, None)]
    for dd, qd in ((1, pd), (0, 1 - pd)):
        for oo, qo in ((1, po), (0, 1 - po)):
            out.append(((1 - pl) * qd * qo, (up(d, dd), up(o, oo))))
    return rew, out


def solve(p, horizon=H):
    states = [(d, o) for d in range(3) for o in range(3)]
    v = {s: 0.0 for s in states}
    pol = []
    for _ in range(horizon):
        nv, step = {}, {}
        for s in states:
            best = None
            for a in ACTS:
                r, out = model(s[0], s[1], a, p)
                terms = [r] + [q * (-PEN if ns is None else v[ns])
                               for q, ns in out]
                val = math.fsum(terms)
                if best is None or val > best[0] + 1e-12:
                    best = (val, a)
            nv[s], step[s] = best
        v = nv
        pol.insert(0, step)
    return v, pol


def likely_path(pol, p, s=(2, 0)):
    seq = []
    for t in range(len(pol)):
        a = pol[t][s]
        seq.append(a)
        out = model(s[0], s[1], a, p)[1]
        q, ns = max(out, key=lambda x: (x[0], x[1] is not None))
        if ns is None:
            break
        s = ns
    return "".join(seq)


def evaluate(pol, p, horizon=H):
    """Value of a fixed (time-indexed) policy under parameters p."""
    states = [(d, o) for d in range(3) for o in range(3)]
    v = {s: 0.0 for s in states}
    for t in range(horizon - 1, -1, -1):
        nv = {}
        for s in states:
            r, out = model(s[0], s[1], pol[t][s], p)
            nv[s] = math.fsum([r] + [q * (-PEN if ns is None else v[ns])
                                     for q, ns in out])
        v = nv
    return v


if __name__ == "__main__":
    rng = random.Random(38762)
    v0, pol0 = solve(PAR)
    base_path = likely_path(pol0, PAR)
    first, paths, regrets = {}, {}, []
    draws = 2000
    for _ in range(draws):
        p = {}
        for k, x in sorted(PAR.items()):
            y = x * rng.uniform(0.75, 1.25)
            p[k] = min(1.0, y) if not k.endswith("gain") else y
        v, pol = solve(p)
        a = pol[0][(2, 0)]
        first[a] = first.get(a, 0) + 1
        lp = likely_path(pol, p)
        paths[lp] = paths.get(lp, 0) + 1
        vb = evaluate(pol0, p)[(2, 0)]
        regrets.append((v[(2, 0)] - vb) / v[(2, 0)])
    print("baseline path from D=2, O=0: {}".format(base_path))
    print("first action over {:,} draws:".format(draws))
    for a in sorted(first):
        print("   {}  {:.4f}".format(a, first[a] / draws))
    top = sorted(paths.items(), key=lambda kv: (-kv[1], kv[0]))[:4]
    print("most frequent likely paths:")
    for pth, n in top:
        print("   {:<6s} {:.4f}".format(pth, n / draws))
    regrets.sort()
    print("relative regret of the baseline policy:")
    print("   mean {:.4f}  median {:.4f}  95th pct {:.4f}  max {:.4f}"
          .format(math.fsum(regrets) / draws, regrets[draws // 2],
                  regrets[int(0.95 * draws)], regrets[-1]))
    for g10 in range(30, 130, 5):
        p = dict(PAR)
        p["r_gain"] = g10 / 10.0
        pol = solve(p)[1]
        used = [st[s] for st in pol for s in st if st[s] == "R"]
        if used:
            print("R first enters the policy at r_gain = {:.1f}".format(
                g10 / 10.0))
            break
    else:
        print("R never enters the policy for r_gain up to 12.5")

Single source and citation

Fan, Y. (2026). Dissolving Entrenched Priors, Shattering the Illusion of Explanatory Depth and Anti-Backfire Persuasion Mechanics (Version 1.0.0), Chapter 6: Question Sequences as a Decision Process: a Simulated Optimum under Illustrative Parameters and Its Sensitivity. 5D Library. DOI pending

DOI pending · monograph page goes live after publication · 5DL-B-387 · v1.0.0 · CC-BY-NC-ND-4.0

BibTeX
@book{fan2026387,
  author    = {Fan, Yafu},
  title     = {Dissolving Entrenched Priors, Shattering the Illusion of Explanatory Depth and Anti-Backfire Persuasion Mechanics},
  year      = {2026},
  publisher = {5D Library},
  edition   = {1.0.0},
  note      = {DOI pending}
}

Other chapter answers in this book