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 x7Show 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
- Chapter 1 · Method: Three Measures of Multi-Site Visual Drift, Grades of Evidence and the Cai-Fen Module of the Yingzao Fashi
- Chapter 2 · Token Algebra: Three Layers, Themes as Functions and the Dependency Graph of Thirty Sites
- Chapter 3 · Perceptually Uniform Colour Spaces: From sRGB to CIELAB, CIEDE2000 and OKLab
- Chapter 4 · Perceptually Uniform Ramps: Lightness Steps, Contrast Constraints, Gamut Clipping and Dark-Theme Inversion
- Chapter 5 · The 50-Millisecond First Impression: Exposure, Complexity, Prototypicality and the Distance to a Sale
- Chapter 6 · Governing Thirty Sites: Release, Drift Detection, Per-Brand Re-Theming, Audit and Rollback
- Chapter 8 · Practice: Unifying the Palettes of Five Representative Hengyu Sites, with a Pre-Registered First-Impression Test