What does Design-Token Algebra conclude, in numbers, about “Playbooks for the Four Kinds of Site, and the Distillation Spec for the Four Kits”?

Answer: The three states read differently too. On the sRGB mix, "in progress" reaches 5.00 on white, "done" 13.93 and "not started" only 1.75; on the chord ramp "in progress" reaches 3.43, still above the 3.0 floor for components, and "done" 7.97. On both ramps the three states are more than 20 apart, easy to tell apart. The equal-lightness method has 3 stops whose chroma is cut by the sRGB gamut, so the ends of the ramp are greyer than the anchor, the gamut clipping of Chapter 4.

Scope of the numbers: All brands, sites, colours and ratings are invented, every calculation comes from the book's programs, and legal matters are described only in general terms, not as legal advice. Each hypothesis states what would refute it.

中文版

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.0167, 0.1225, 0.40, 0.7686, 01, 02

GK01 clean set                token_graph PASS   OK
GK02 p22 R03 broken alias     token_graph REFUSE K1    broken=["comp.badge.bg"]
GK03 p22 C02 alias cycle      token_graph REFUSE K2    cycles=[["sys.color.focus-ring","sys.color.link"]]
GK04 p22 K05 layer skip       token_graph REFUSE K4    layer=["comp.card.radius"]
GK05 p65 B05 literal          token_graph REFUSE K5    literal=["comp.badge.bg"]
GK06 p22 B07 type clash       token_graph REFUSE K6    type_clash=["comp.button.primary.pad"]
GK07 four-hop chain warns     token_graph PASS   OK    warnings=["DEPTH comp.chart.mark"]
GK08 p73 theme cycle          token_graph REFUSE K2    cycles=[["t:card-dusk","t:card-moon","t:card-night"]]
GK09 p73 missing theme parent token_graph REFUSE K1    broken=["t:card-sun"]
GK10 Sharma pair 1            delta_e     PASS   OK    de00=2.0425; band=2.5; mode="max"
GK11 p10 B07 primary          delta_e     PASS   OK    de00=1.4971; band=2.0; mode="max"
GK12 p10 B08 primary          delta_e     REFUSE K3    de00=12.272; band=2.0; mode="max"
GK13 p71 muted fix, band 1.0  delta_e     PASS   OK    de00=0.7686; band=1.0; mode="max"
GK14 p64 wine vs danger       delta_e     REFUSE K3    de00=9.2967; band=10.0; mode="min"
GK15 p64 report vs card       delta_e     PASS   OK    de00=17.3691; band=10.0; mode="min"
GK16 p72 jade chords          ramp        PASS   OK    cv=0.0167; step_min=6.99; step_max=7.32
     ramp #C2FFDF #97E5BE #7BC8A3 #62AF8A #4C9976 #378563 #217251 #005D3E #00462E
GK17 p72 jade equal L         ramp        REFUSE K8    cv=0.1225; step_min=5.92; step_max=8.39
GK18 15 steps in L 0.40-0.38  ramp        REFUSE K7+K8 cv=0.8823; step_min=0.0; step_max=0.43
GK19 two steps                ramp        REFUSE E0
GK20 colour by name           delta_e     REFUSE E0
cases 20; first codes E0 x2, K1 x2, K2 x2, K3 x2, K4 x1, K5 x1, K6 x1, K7 x1, K8 x1, OK x7
Show the full program
# Chapter 7. p74: Style-kit additions from this book: ops token_graph, delta_e, ramp; refusal codes K1-K8.
# Each op takes one dict and returns verdict (PASS | REFUSE), code (OK | first refusal), refusals_hit,
# warnings and its result fields, in the style kit's contract. The cases below are the kit's new golden
# table; expected values are this program's own output. Token names and values follow chapter 2 (p20,
# p22), the live colours chapter 1 (p10) and the themes p73.
#   K1 broken link   an alias names a missing token, or a theme ("t:" prefix) a missing parent
#   K2 cycle         an alias chain or a theme "extends" chain returns to itself
#   K3 dE00 out of band   mode "max": dE00 > band (drift); mode "min": dE00 < band (separation)
#   K4 layer skip    a comp token aliases a ref token directly
#   K5 literal       a literal value outside the ref layer
#   K6 type clash    a colour slot resolves to a length, or a length slot to a colour
#   K7 ramp order    L* of the generated ramp is not strictly decreasing
#   K8 ramp uneven   coefficient of variation of the dE00 steps exceeds cv_max (default 0.05)
# Warning DEPTH (more than 3 hops) does not refuse. E0 (bad input) is the kit's existing code, reused.
import json
import re
from statistics import fmean, pstdev
import math

def lin8(c):
    return c / 12.92 if c <= 0.04045 else ((c + 0.055) / 1.055) ** 2.4


def rgb(h):
    return [int(h[i:i + 2], 16) / 255 for i in (1, 3, 5)]


def lum(h):  # WCAG 2.1 relative luminance (0.03928 threshold as the standard writes it)
    v = [c / 12.92 if c <= 0.03928 else ((c + 0.055) / 1.055) ** 2.4 for c in rgb(h)]
    return math.fsum(w * c for w, c in zip((0.2126, 0.7152, 0.0722), v))


def ratio(a, b):
    x, y = lum(a), lum(b)
    return (max(x, y) + 0.05) / (min(x, y) + 0.05)


def lab(h):
    r, g, b = (lin8(c) for c in rgb(h))
    x = math.fsum((0.4124564 * r, 0.3575761 * g, 0.1804375 * b)) / 0.95047
    y = math.fsum((0.2126729 * r, 0.7151522 * g, 0.0721750 * b))
    z = math.fsum((0.0193339 * r, 0.1191920 * g, 0.9503041 * b)) / 1.08883
    e, k = 216 / 24389, 24389 / 27
    f = [t ** (1 / 3) if t > e else (k * t + 16) / 116 for t in (x, y, z)]
    return 116 * f[1] - 16, 500 * (f[0] - f[1]), 200 * (f[1] - f[2])


def de00(h1, h2):  # CIEDE2000 (Sharma, Wu and Dalal 2005)
    (L1, a1, b1), (L2, a2, b2) = labx(h1), labx(h2)
    c7 = ((math.hypot(a1, b1) + math.hypot(a2, b2)) / 2) ** 7
    g = 0.5 * (1 - math.sqrt(c7 / (c7 + 25 ** 7)))
    a1, a2 = (1 + g) * a1, (1 + g) * a2
    c1, c2 = math.hypot(a1, b1), math.hypot(a2, b2)
    h1 = math.degrees(math.atan2(b1, a1)) % 360 if c1 else 0.0
    h2 = math.degrees(math.atan2(b2, a2)) % 360 if c2 else 0.0
    dh = 0.0 if c1 * c2 == 0 else (h2 - h1 if abs(h2 - h1) <= 180 else
                                    (h2 - h1 - 360 if h2 - h1 > 180 else h2 - h1 + 360))
    dH = 2 * math.sqrt(c1 * c2) * math.sin(math.radians(dh / 2))
    lb, cb = (L1 + L2) / 2, (c1 + c2) / 2
    if c1 * c2 == 0:
        hb = h1 + h2
    elif abs(h1 - h2) <= 180:
        hb = (h1 + h2) / 2
    else:
        hb = (h1 + h2 + 360) / 2 if h1 + h2 < 360 else (h1 + h2 - 360) / 2
    t = (1 - 0.17 * math.cos(math.radians(hb - 30)) + 0.24 * math.cos(math.radians(2 * hb))
         + 0.32 * math.cos(math.radians(3 * hb + 6)) - 0.20 * math.cos(math.radians(4 * hb - 63)))
    rc = 2 * math.sqrt(cb ** 7 / (cb ** 7 + 25 ** 7))
    rt = -math.sin(math.radians(60 * math.exp(-(((hb - 275) / 25) ** 2)))) * rc
    sl = 1 + 0.015 * (lb - 50) ** 2 / math.sqrt(20 + (lb - 50) ** 2)
    sc, sh = 1 + 0.045 * cb, 1 + 0.015 * cb * t
    return math.sqrt(((L2 - L1) / sl) ** 2 + ((c2 - c1) / sc) ** 2 + (dH / sh) ** 2
                     + rt * ((c2 - c1) / sc) * (dH / sh))


M1 = ((0.4122214708, 0.5363325363, 0.0514459929), (0.2119034982, 0.6806995451, 0.1073969566),
      (0.0883024619, 0.2817188376, 0.6299787005))
M2 = ((0.2104542553, 0.7936177850, -0.0040720468), (1.9779984951, -2.4285922050, 0.4505937099),
      (0.0259040371, 0.7827717662, -0.8086757660))
I2 = ((1, 0.3963377774, 0.2158037573), (1, -0.1055613458, -0.0638541728), (1, -0.0894841775, -1.2914855480))
I1 = ((4.0767416621, -3.3077115913, 0.2309699292), (-1.2684380046, 2.6097574011, -0.3413193965),
      (-0.0041960863, -0.7034186147, 1.7076147010))


def mul(m, v):
    return [math.fsum(a * b for a, b in zip(row, v)) for row in m]


def oklab(h):  # Ottosson (2020)
    return mul(M2, [math.copysign(abs(c) ** (1 / 3), c) for c in mul(M1, [lin8(c) for c in rgb(h)])])


def from_oklab(L, C, hue):
    v = mul(I1, [c ** 3 for c in mul(I2, (L, C * math.cos(hue), C * math.sin(hue)))])
    if any(c < -1e-9 or c > 1 + 1e-9 for c in v):
        return None
    v = [12.92 * c if c <= 0.0031308 else 1.055 * c ** (1 / 2.4) - 0.055 for c in (max(0.0, c) for c in v)]
    return "#%02X%02X%02X" % tuple(round(min(1.0, c) * 255) for c in v)


HEX = "0123456789ABCDEF"
ALIAS = re.compile(r"^\{([a-z0-9.\-]+)\}$")
COLOUR_END = {"bg", "fg", "border", "focus", "error", "mark", "strike-fg", "fill", "track"}
LENGTH_END = {"pad", "radius", "size", "gap"}


class Refuse(Exception):
    pass


def labx(x):
    if isinstance(x, (list, tuple)) and len(x) == 3:
        return tuple(float(v) for v in x)
    if isinstance(x, str) and len(x) == 7 and x[0] == "#" and all(c in HEX for c in x[1:].upper()):
        return lab(x.upper())
    raise Refuse("E0")


def answer(op, hits, warnings=(), **fields):
    out = {"op": op, "verdict": "REFUSE" if hits else "PASS", "code": hits[0] if hits else "OK",
           "refusals_hit": hits, "warnings": list(warnings)}
    out.update(fields)
    return out


def expected(name):
    last = name.split(".")[-1]
    if name.startswith("sys.color.") or (name.startswith("comp.") and last in COLOUR_END):
        return "colour"
    if name.startswith(("sys.space.", "sys.radius.", "sys.size.")) or (name.startswith("comp.")
                                                                         and last in LENGTH_END):
        return "length"
    return None


def token_graph(inp):
    t, themes = inp["tokens"], inp.get("themes", {})
    broken, cycles, layer, literal, clash, deep = [], [], [], [], [], []
    for n in sorted(t):
        seen, cur, ok = [n], t[n], True
        while ALIAS.match(cur):
            nxt = ALIAS.match(cur).group(1)
            if nxt not in t:
                broken.append(n)
                ok = False
                break
            if nxt in seen:
                ring = sorted(seen[seen.index(nxt):])
                if ring not in cycles:
                    cycles.append(ring)
                ok = False
                break
            seen.append(nxt)
            cur = t[nxt]
        m = ALIAS.match(t[n])
        if m and n.startswith("comp.") and m.group(1).startswith("ref."):
            layer.append(n)
        if not m and not n.startswith("ref."):
            literal.append(n)
        if ok:
            kind = "colour" if cur.startswith("#") else "length" if cur.endswith("px") else None
            if expected(n) and kind and expected(n) != kind:
                clash.append(n)
            if len(seen) - 1 > 3:
                deep.append(n)
    for th in sorted(themes):
        seen, cur = [], th
        while cur in themes and cur not in seen:
            seen.append(cur)
            cur = themes[cur].get("extends")
        if cur is not None and cur not in themes:
            broken.append("t:" + seen[-1])
        elif cur is not None:
            ring = sorted("t:" + s for s in seen[seen.index(cur):])
            if ring not in cycles:
                cycles.append(ring)
    hits = [c for c, bad in (("K1", broken), ("K2", cycles), ("K4", layer), ("K5", literal), ("K6", clash))
            if bad]
    return answer("token_graph", hits, ["DEPTH " + d for d in deep], broken=sorted(set(broken)),
                  cycles=cycles, layer=layer, literal=literal, type_clash=clash)


def delta_e(inp):
    band, mode = float(inp.get("band", 2.0)), inp.get("mode", "max")
    if mode not in ("max", "min"):
        raise Refuse("E0")
    d = de00(inp["a"], inp["b"])
    bad = d > band if mode == "max" else d < band
    return answer("delta_e", ["K3"] if bad else [], de00=round(d, 4), band=band, mode=mode)


def ramp(inp):
    anchor, n = inp["anchor"], int(inp.get("steps", 9))
    hi, lo = float(inp.get("l_max", 0.95)), float(inp.get("l_min", 0.35))
    cv_max, mode = float(inp.get("cv_max", 0.05)), inp.get("mode", "chord")
    if not (3 <= n <= 15 and 0 < lo < hi < 1) or mode not in ("chord", "oklab-l"):
        raise Refuse("E0")
    labx(anchor)
    L0, a0, b0 = oklab(anchor.upper())
    C0, hue = math.hypot(a0, b0), math.atan2(b0, a0)

    def clip(L):
        if from_oklab(L, C0, hue):
            return from_oklab(L, C0, hue)
        a, b = 0.0, C0
        for _ in range(40):
            m = (a + b) / 2
            a, b = (m, b) if from_oklab(L, m, hue) else (a, m)
        return from_oklab(L, a, hue)

    if mode == "oklab-l":
        out = [clip(hi - (hi - lo) * k / (n - 1)) for k in range(n)]
    else:
        path = [clip(hi - (hi - lo) * i / 600) for i in range(601)]

        def walk(d):
            idx = [0]
            for _ in range(n - 1):
                j = idx[-1] + 1
                while j < 600 and de00(path[idx[-1]], path[j]) < d:
                    j += 1
                idx.append(j)
            return idx

        a, b = 0.5, 40.0
        for _ in range(30):
            m = (a + b) / 2
            a, b = (m, b) if walk(m)[-1] < 600 else (a, m)
        idx = walk(a)
        idx[-1] = 600
        out = [path[i] for i in idx]
    steps = [de00(x, y) for x, y in zip(out, out[1:])]
    cv = pstdev(steps) / fmean(steps)
    Ls = [lab(h)[0] for h in out]
    hits = (["K7"] if not all(x > y for x, y in zip(Ls, Ls[1:])) else []) + (["K8"] if cv > cv_max else [])
    return answer("ramp", hits, ramp=out, cv=round(cv, 4), step_min=round(min(steps), 2),
                  step_max=round(max(steps), 2))


OPS = {"token_graph": token_graph, "delta_e": delta_e, "ramp": ramp}


def run(inp):
    try:
        if inp.get("op") not in OPS:
            raise Refuse("E0")
        return OPS[inp["op"]](inp)
    except (Refuse, KeyError, TypeError, ValueError):
        return answer(inp.get("op"), ["E0"])


BASE = {"ref.color.ink.900": "#1B1B20", "ref.color.gold.500": "#B8913F", "ref.color.wine.700": "#8C2F39",
        "ref.color.ink.050": "#F7F5F0", "ref.radius.2": "8px", "ref.space.4": "16px",
        "sys.color.text-body": "{ref.color.ink.900}", "sys.color.surface": "{ref.color.ink.050}",
        "sys.color.primary": "{ref.color.wine.700}", "sys.color.accent": "{ref.color.gold.500}",
        "sys.color.link": "{sys.color.primary}", "sys.color.focus-ring": "{sys.color.accent}",
        "sys.radius.card": "{ref.radius.2}", "sys.space.inset-md": "{ref.space.4}",
        "comp.button.primary.bg": "{sys.color.primary}", "comp.button.primary.pad": "{sys.space.inset-md}",
        "comp.button.ghost.fg": "{sys.color.link}", "comp.card.bg": "{sys.color.surface}",
        "comp.card.radius": "{sys.radius.card}", "comp.badge.bg": "{sys.color.accent}",
        "comp.input.focus": "{sys.color.focus-ring}", "comp.chart.mark": "{comp.button.primary.bg}"}


def g(**edits):
    return {"op": "token_graph", "tokens": dict(BASE, **edits)}


CASES = [
    ("GK01", "clean set", g()),
    ("GK02", "p22 R03 broken alias", g(**{"comp.badge.bg": "{sys.color.highlight}"})),
    ("GK03", "p22 C02 alias cycle", g(**{"sys.color.link": "{sys.color.focus-ring}",
                                         "sys.color.focus-ring": "{sys.color.link}"})),
    ("GK04", "p22 K05 layer skip", g(**{"comp.card.radius": "{ref.radius.2}"})),
    ("GK05", "p65 B05 literal", g(**{"comp.badge.bg": "#B8913F"})),
    ("GK06", "p22 B07 type clash", g(**{"comp.button.primary.pad": "{sys.color.accent}"})),
    ("GK07", "four-hop chain warns", g(**{"comp.chart.mark": "{comp.button.ghost.fg}"})),
    ("GK08", "p73 theme cycle", dict(g(), themes={"card-base": {}, "card-night": {"extends": "card-dusk"},
                                                  "card-moon": {"extends": "card-night"},
                                                  "card-dusk": {"extends": "card-moon"}})),
    ("GK09", "p73 missing theme parent", dict(g(), themes={"card-base": {},
                                                           "card-sun": {"extends": "card-solar"}})),
    ("GK10", "Sharma pair 1", {"op": "delta_e", "a": [50, 2.6772, -79.7751], "b": [50, 0, -82.7485],
                               "band": 2.5}),
    ("GK11", "p10 B07 primary", {"op": "delta_e", "a": "#863036", "b": "#8C2F39"}),
    ("GK12", "p10 B08 primary", {"op": "delta_e", "a": "#900A05", "b": "#8C2F39"}),
    ("GK13", "p71 muted fix, band 1.0", {"op": "delta_e", "a": "#2773C9", "b": "#2771C7", "band": 1.0}),
    ("GK14", "p64 wine vs danger", {"op": "delta_e", "a": "#A3242F", "b": "#C33A32", "band": 10.0,
                                    "mode": "min"}),
    ("GK15", "p64 report vs card", {"op": "delta_e", "a": "#1F5FA8", "b": "#6B4FA0", "band": 10.0,
                                    "mode": "min"}),
    ("GK16", "p72 jade chords", {"op": "ramp", "anchor": "#2E7D5B"}),
    ("GK17", "p72 jade equal L", {"op": "ramp", "anchor": "#2E7D5B", "mode": "oklab-l"}),
    ("GK18", "15 steps in L 0.40-0.38", {"op": "ramp", "anchor": "#2E7D5B", "mode": "oklab-l", "steps": 15,
                                         "l_max": 0.40, "l_min": 0.38}),
    ("GK19", "two steps", {"op": "ramp", "anchor": "#2E7D5B", "steps": 2}),
    ("GK20", "colour by name", {"op": "delta_e", "a": "wine", "b": "#8C2F39"}),
]
SHOW = {"token_graph": ("broken", "cycles", "layer", "literal", "type_clash", "warnings"),
        "delta_e": ("de00", "band", "mode"), "ramp": ("cv", "step_min", "step_max")}

if __name__ == "__main__":
    tally = {}
    for cid, note, inp in CASES:
        out = run(inp)
        tally[out["code"]] = tally.get(out["code"], 0) + 1
        keys = [k for k in SHOW.get(out["op"], ()) if out["code"] != "E0"]
        detail = "; ".join("{}={}".format(k, json.dumps(out[k], separators=(",", ":"))) for k in keys
                           if out.get(k) not in ([], None))
        hits = "+".join(out["refusals_hit"]) or "OK"
        line = "{} {:24} {:11} {:6} {:5} {}".format(cid, note, out["op"], out["verdict"], hits, detail)
        print(line.rstrip())
        if cid == "GK16":
            print("     ramp " + " ".join(out["ramp"]))
    codes = ", ".join("{} x{}".format(k, v) for k, v in sorted(tally.items()))
    print("cases {}; first codes {}".format(len(CASES), codes))

Single source and citation

Fan, Y. (2026). Design-Token Algebra across Thirty Sites, Perceptually Uniform Colour Spaces and the Millisecond Science of Brand-Authority First Impressions (Version 0.1.0), Chapter 7: Playbooks for the Four Kinds of Site, and the Distillation Spec for the Four Kits. 5D Library. DOI pending

DOI pending · monograph page goes live after publication · 5DL-B-140 · v0.1.0 · CC-BY-NC-ND-4.0

BibTeX
@book{fan2026140,
  author    = {Fan, Yafu},
  title     = {Design-Token Algebra across Thirty Sites, Perceptually Uniform Colour Spaces and the Millisecond Science of Brand-Authority First Impressions},
  year      = {2026},
  publisher = {5D Library},
  edition   = {0.1.0},
  note      = {DOI pending}
}

Other chapter answers in this book