What does Modular Numerology conclude, in numbers, about “The Five Grids and the Eighty-One Numbers: Convolution and Modulo 80”?
Answer: Chapter 5 writes the five grids as convolutions of stroke counts and the eighty-one numbers as a digital root modulo 80: with Kangxi counts the total grid takes 61 values, but 18 of them hold eight names in ten; the good numbers crowd the low range where stroke sums fall, so each grid is good more often than the 0.432 of 35/81; another stroke convention flips each grid's label for 0.244 to 0.473 of names.
Scope of the numbers: Marked boxes separate published evidence, runnable Python calculations (16 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.244, 0.432, 0.473, 35, 81
even spread over the 81 numbers: good share 0.432
grid good share label flips between the two counts
simp Kangxi
heaven 0.722 0.678 0.244
person 0.612 0.565 0.410
earth 0.608 0.553 0.430
outer 0.628 0.551 0.308
total 0.539 0.515 0.473
all five good: simp 0.092 Kangxi 0.072 flips 0.135
all five good, by surname (Kangxi):
lowest 0.000, median 0.083, highest 0.137
Reading: good numbers crowd the low end of the list, where
stroke sums fall, so each grid is good more often than 35/81.
Changing the counting rule flips a grid's label for one name
in four to one in two. Whether all five are good depends heavily
on the surname: for some surnames it never happens.Show the full program
# Chapter 5. Labels, base rates and what changes with the counting rule.
# The same 547,560 names as in p10, now counted both ways at once (the
# lists are aligned character by character). For each grid: the share of
# names whose grid falls on a "good" number, against the 35/81 that an
# even spread would give; the share whose label flips between simplified
# and Kangxi counts; and how strongly the surname alone fixes the result.
from statistics import median
GOOD = {1, 3, 5, 6, 7, 8, 11, 13, 15, 16, 17, 18, 21, 23, 24, 25, 29,
31, 32, 33, 35, 37, 39, 41, 45, 47, 48, 52, 57, 61, 63, 65, 67,
68, 81}
KEYS = ("heaven", "person", "earth", "outer", "total")
SUR_S = """4 7 7 6 7 7 11 9 7 8 10 6 3 6 9 10 7 10 8 8 8 11 12 7 10 6 12 5
4 11 12 12 5 12 15 10 14 12 7 3 7 5 12 7 17 6 2 6 7 9 5 9 11 9 14 7 7 8 5
14 10 10 4 4 5 7 8 14 10 8 6 9 13 9 5 5 15 9 10 4 9 7 3 10 7 8 10 4 6 6"""
SUR_K = """4 7 11 15 16 13 12 14 7 8 10 10 10 6 11 15 7 10 8 20 19 11 17 7 10
11 17 12 19 11 12 12 5 15 16 10 17 17 7 3 7 15 12 22 18 7 2 6 8 9 16 9 11
17 19 16 8 8 5 14 13 10 9 4 5 17 8 14 10 12 7 9 13 9 16 5 15 12 21 4 14
12 15 16 20 8 13 4 6 13"""
GIV_S = """6 7 7 8 6 15 5 9 14 7 12 15 6 9 9 8 10 10 8 12 17 5 6 10 4 12 9 8 7
10 6 10 9 8 10 11 8 8 3 11 11 7 12 14 9 14 12 12 14 8 9 8 4 5 4 8 5 9 6 5
11 11 10 6 6 7 7 12 13 10 12 12 9 10 8 8 6 8"""
GIV_K = """11 10 7 11 14 15 5 9 16 19 11 15 9 10 9 12 10 18 8 12 17 5 10 10 4
15 10 9 7 11 6 11 9 9 11 11 8 8 3 12 11 10 12 14 9 14 12 13 15 13 14 8 12
16 14 11 5 9 9 23 11 14 11 13 16 17 15 16 14 11 13 13 12 12 8 10 6 8"""
def nums(s):
return [int(x) for x in s.split()]
def labels(s, a, b):
vals = (s + 1, s + a, a + b, b + 1, s + a + b)
return tuple((1 + (v - 1) % 80) in GOOD for v in vals)
if __name__ == "__main__":
sur = list(zip(nums(SUR_S), nums(SUR_K)))
giv = list(zip(nums(GIV_S), nums(GIV_K)))
n = 0
good = {"simp": [0] * 5, "kx": [0] * 5}
allgood = {"simp": 0, "kx": 0}
flip, allflip = [0] * 5, 0
per_surname = []
for ss, sk in sur:
n_s, all_s = 0, 0
for as_, ak in giv:
for bs, bk in giv:
ls, lk = labels(ss, as_, bs), labels(sk, ak, bk)
n += 1
n_s += 1
for i in range(5):
good["simp"][i] += ls[i]
good["kx"][i] += lk[i]
flip[i] += ls[i] != lk[i]
allgood["simp"] += all(ls)
allgood["kx"] += all(lk)
allflip += all(ls) != all(lk)
all_s += all(lk)
per_surname.append(all_s / n_s)
print(" even spread over the 81 numbers: good share {:.3f}".format(
35 / 81))
print(" grid good share label flips between the two counts")
print(" simp Kangxi")
for i, k in enumerate(KEYS):
print(" {:7s} {:.3f} {:.3f} {:.3f}".format(
k, good["simp"][i] / n, good["kx"][i] / n, flip[i] / n))
print(" all five good: simp {:.3f} Kangxi {:.3f} flips {:.3f}"
.format(allgood["simp"] / n, allgood["kx"] / n, allflip / n))
per_surname.sort()
print(" all five good, by surname (Kangxi):")
print(" lowest {:.3f}, median {:.3f}, highest {:.3f}".format(
per_surname[0],
median(per_surname),
per_surname[-1]))
print("\nReading: good numbers crowd the low end of the list, where")
print("stroke sums fall, so each grid is good more often than 35/81.")
print("Changing the counting rule flips a grid's label for one name")
print("in four to one in two. Whether all five are good depends heavily")
print("on the surname: for some surnames it never happens.")Single source and citation
Fan, Y. (2026). Modular Numerology, Character-Stroke Hashes and Residue-Class Distributions (Version 1.0.0), Chapter 5: The Five Grids and the Eighty-One Numbers: Convolution and Modulo 80. 5D Library. https://doi.org/10.5281/zenodo.24090178
DOI: 10.5281/zenodo.24090178 · Read the monograph · 5DL-B-065 · v1.0.0 · CC-BY-NC-ND-4.0
BibTeX
@book{fan2026065,
author = {Fan, Yafu},
title = {Modular Numerology, Character-Stroke Hashes and Residue-Class Distributions},
year = {2026},
publisher = {5D Library},
edition = {1.0.0},
doi = {10.5281/zenodo.24090178},
url = {https://doi.org/10.5281/zenodo.24090178}
}Other chapter answers in this book
- Chapter 1 · The Digital Root Is the Residue Modulo 9
- Chapter 2 · The Base Rates of Life Path Numbers
- Chapter 3 · The Alphabet Modulo 9: Name Numbers and Two Letter Tables
- Chapter 4 · Kangxi Strokes: Radical Restoration Is a Fixed Map
- Chapter 6 · Phone Numbers: Modulo 80, XOR and Compressed Numbers
- Chapter 7 · Eighty-One Parts, Five Hundred and Forty Radicals and the Kangxi Dictionary
- Chapter 8 · A Four-Step Check and a Pre-Registered Matching Test