What does Antifragile Reputation and Audience Sovereignty conclude, in numbers, about “Hash Chains of Delivery Evidence and Daily Merkle Roots: Proving When a Record Existed, Not That It Is True”?

Answer: Chapter 5 keeps delivery evidence in a SHA-256 hash chain with daily Merkle roots: tampering that recomputes every later hash is caught by the chain alone at a rate of 0.000 and at 1.000 with daily external anchors, and personal data never enter the chain.

Scope of the numbers: Its parameters are illustrative; all calculations are generated by its programs; it is general business guidance, not legal advice. Marked boxes separate published evidence, runnable Python calculations (22 programs), classical sources and the author's hypotheses.

中文版

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.000, 1.000

A. 1,000 records; head a19511f7b7db3fc7; day-1 anchor fa8f13f31108db3c
B. detection rate     chain only   chain + daily anchors
   edit               1.000        1.000
   recompute          0.000        1.000
C. hashes recomputed to reach the first break: mean 514.1, max 999
D. a record false from the moment it was written: detected = False
Show the full program
# Chapter 5. p51: a SHA-256 hash chain of delivery events.
# Each record holds only minimal fields: sequence, day, event code, a
# keyed reference (BLAKE2b with a secret key over the order reference,
# so no personal data enters the chain) and a status. Link rule:
# h_i = SHA-256(h_{i-1} | record_i). The last hash of each day is the
# daily anchor, standing in for an external time-stamp token (RFC
# 3161 style). Three kinds of change are tried: edit one record only,
# edit and recompute every later hash, and a record that was false
# when it was first written. 1,000 events over 10 days; synthetic.
import hashlib
import random
import statistics

DAYS, PER_DAY = 10, 100
KEY = b"b403-demo-key-not-a-real-secret"
CODES = ("PACKED", "HANDED_TO_COURIER", "DELIVERED")


def keyed_ref(order_ref):
    return hashlib.blake2b(order_ref.encode(), key=KEY,
                           digest_size=8).hexdigest()


def link(prev, rec):
    body = "|".join(str(x) for x in rec)
    return hashlib.sha256((prev + "|" + body).encode()).hexdigest()


def build(recs):
    out, prev = [], "0" * 64
    for r in recs:
        prev = link(prev, r)
        out.append(prev)
    return out


def first_break(recs, stored):
    prev = "0" * 64
    for i, r in enumerate(recs):
        prev = link(prev, r)
        if prev != stored[i]:
            return i, i + 1
    return None, len(recs)


if __name__ == "__main__":
    rng = random.Random(40501)
    recs = []
    for i in range(DAYS * PER_DAY):
        recs.append((i, i // PER_DAY, CODES[i % 3],
                     keyed_ref("order-{}".format(i // 3)), "ok"))
    stored = build(recs)
    anchors = [stored[(d + 1) * PER_DAY - 1] for d in range(DAYS)]
    print("A. {:,} records; head {}; day-1 anchor {}".format(
        len(recs), stored[0][:16], anchors[0][:16]))
    trials = 400
    det_chain = {"edit": 0, "recompute": 0}
    det_anchor = {"edit": 0, "recompute": 0}
    cost = []
    for t in range(trials):
        kind = "edit" if t % 2 == 0 else "recompute"
        j = rng.randrange(len(recs))
        bad = list(recs)
        r = bad[j]
        bad[j] = (r[0], r[1], r[2], r[3], "damaged")
        s2 = list(stored)
        if kind == "recompute":
            s2 = build(bad)
        where, n = first_break(bad, s2)
        if where is not None:
            det_chain[kind] += 1
            cost.append(n)
        day_ends = [s2[(d + 1) * PER_DAY - 1] for d in range(DAYS)]
        if where is not None or day_ends != anchors:
            det_anchor[kind] += 1
    half = trials // 2
    print("B. detection rate     chain only   chain + daily anchors")
    for k in ("edit", "recompute"):
        print("   {:<18} {:.3f}        {:.3f}".format(
            k, det_chain[k] / half, det_anchor[k] / half))
    print("C. hashes recomputed to reach the first break: mean {:.1f},"
          " max {}".format(statistics.fmean(cost), max(cost)))
    lie = list(recs)
    lie[500] = (500, 5, "DELIVERED", keyed_ref("order-166"), "ok")
    s3 = build(lie)
    where, _ = first_break(lie, s3)
    print("D. a record false from the moment it was written:"
          " detected = {}".format(where is not None))

Single source and citation

Fan, Y. (2026). Antifragile Reputation Judo, Evidence-Backed Smear Neutralisation and Platform-Independent Audience Sovereignty (Version 1.0.0), Chapter 5: Hash Chains of Delivery Evidence and Daily Merkle Roots: Proving When a Record Existed, Not That It Is True. 5D Library. DOI pending

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

BibTeX
@book{fan2026403,
  author    = {Fan, Yafu},
  title     = {Antifragile Reputation Judo, Evidence-Backed Smear Neutralisation and Platform-Independent Audience Sovereignty},
  year      = {2026},
  publisher = {5D Library},
  edition   = {1.0.0},
  note      = {DOI pending}
}

Other chapter answers in this book