VANIAN TESSERACTICS
Tesseractions
Tilings for Non-uniform Denominators
Dr. L. Van Warren - Original Idea
Kimi K3, Gemini Flash 3.6 - Assistance with Mathematical Development
Being a Volume of the AddSubMulDivia Series,
with Selections from the Companion Series IntDiffLogExpia
An Interactive HTML5 Edition · Set by the Press
Requires an internet connection for mathematical typesetting (MathJax).
❦
Dedication
To the mosaicists of Rome, who first made wholes from unequal tiles; to Pythagoras, who held the four sacred; to Hinton, who named the fourth dimension; to Eudoxus and Archimedes, who exhausted what they could not count; and to Van, who asked why the pieces had to be equal.
Canonical Glossary & Notation
The Press sets forth the settled terminology. The objects are unchanged throughout; only the tiles vary.
| Term | Meaning |
|---|---|
| tesseraction | a part-against-whole object $\tes{A}{\Omega}{\rho}$; an act of tiling |
| tessera | one weighted piece of an opus |
| opus | the whole $\Omega$, together with its tiling rule |
| tiling rule | the weight assignment $w$ (discrete) or density $\rho$ (continuous) |
| vermiculation | refinement: passage to finer tesserae |
| equitesseral | equal-tiled; the classical fractions |
| proper / improper | value in $[0,1]$ / value outside it |
| pooling | the mediant sum of two tesseractions over juxtaposed opuses |
| ascent | iteration of a tesseraction against itself: powers |
| tesseractics | the discipline |
| Vanian | of the founder's school |
Section Index & Enhancement Map
Every chapter and widget carries a stable HTML id. Cite the id when requesting revisions.
| id | Contents | Widgets |
|---|---|---|
ch01 | Founding question; where tesseractions already live | — |
ch02 | Foundations; Theorem of Equivalent Shares; product & coproduct | w01 builder, w02 vermiculation, w03 mirror |
ch03 | Addition; inclusion–exclusion; pooling; Simpson | w04, w05 |
ch04 | Subtraction; signed shares; Jordan decomposition | w06 |
ch05 | Multiplication; Fubini; telescoping | w07, w08 |
ch06 | Division; reciprocal swap; quotitive; mixed shares | w09 |
ch07 | Powers; Tesseract Theorem; chambers; roots | w10, w11 |
ch08 | Axiom of Approach; infinite ascent; logarithms | w12, w13 |
ch09 | The natural rung; $e$; the gauge | w14 |
ch10 | Differentiation of tesseractions | w15 |
ch11 | Accumulation / occupancy | — |
ch12 | Exponential morphing; information | w16 |
ch13 | Equi-distribution; CFD grids; ALE; airfoil meshing | w17, w18 |
ch14–ch17 | Forms, quantum/stochastic, relativity, categories | hooks reserved w19+ |
bm-* | Closure tables, named theorems, errata, index, reading | — |
Every widget wNN has a toggleable Python companion pyNN immediately
beneath it — self-contained numpy/matplotlib source, with a Colab jump-out badge and a zero-setup
fallback (paste into colab.new). The companions reproduce the widget's theorem in the
Press palette; the motivated reader runs them as-is.
Part 0 · The Question and the Landscape
Chapter 1 · The Founding Question
So I was recently reviewing fractions, and the denominator of a fraction is the number of equal-sized pieces a (virtual?) original whole is divided into, compared with the numerator, which determines the value of the entire fractional expression. So then I thought: what if we had a system where the original whole is divided into some number of variable-sized pieces, and out of necessity one provides a rule, function, or relation on how that virtual original whole would be subdivided, that for utility would also give you the size of the particular piece you were dealing with? This would result in the emergence of a whole logical system of reasoning, along with its cognate notation, that one could derive statements of truth, or theorems about.
One could specify the puzzle-piece in question as simply the integral of some specific rule with limits as to where the boundary of the segment began and ended. For rules that partition the denominator's original whole in one dimension, one would need only a one-dimensional rule, along with the limits of integration, to get a definite result. We could also divide the denominator in two directions, in which case we would use the definite double integral, with two sets of limits, and so on, partitioning in as many dimensions as we would like.
Has any such number and notation system already been formalized? If so, what is its utility — and if not, how might we design one?
— the founding question & pun on definite results
§1.1 · The Press Responds: Where Tesseractions Already Live
Short answer: pieces of this have been formalized many times, and the grand unifying version is one of the crown jewels of twentieth-century mathematics — measure theory, with probability theory as its normalized special case. The founding vocabulary translates cleanly:
| Vanian term | Standard term |
|---|---|
| virtual original whole | a measure space $X$ |
| rule for subdividing | a measure $\mu$, or a density $\rho$ with $\mu(A)=\int_A\rho$ |
| method of specifying the piece | a measurable subset $A$ (or an index set, discretely) |
| the tesseraction's value | the share $\mu(A)/\mu(X) = \int_A\rho \;/\; \int_X\rho$ |
One key reframing the question forces: in an ordinary fraction the numerator is just a count — “how many pieces” — which only works because all pieces are identical. Once pieces vary, the numerator must generalize from a count to a selection: which pieces. That single move is basically the birth of measure theory.
- The discrete case. Pieces $i$ with sizes $w_i$; the share of a selection $S$ is $\sum_{i\in S} w_i \;/\; \sum_i w_i$. Instances: softmax/attention weights in neural networks (tesseractions computed trillions of times daily); the Boltzmann distribution, whose denominator is literally called the partition function; weighted averages; the medieval rule of alligation.
- The integral case. With density $\rho$, the share of $[a,b]$ is $\int_a^b\rho \;/\; \int\rho$. When $\rho$ is normalized, the cumulative function $F(x)=\int_{-\infty}^x \rho$ is the “running tesseraction from the left edge,” and its inverse $F^{-1}$ solves the cutting problem — where do I cut so the piece has a prescribed size? That inverse problem alone generates medians, percentiles, and much of statistics.
- Non-uniform rulers. The Riemann–Stieltjes integral $\int f\,dg$ integrates against a ruler whose tick spacing varies — variable-sized pieces built into the integral itself.
- Higher dimensions. Exactly as the founding question guessed — product measures and multiple integrals; the share of a country's population in a region is $\iint_{\text{region}}\rho \;/\; \iint_{\text{total}}\rho$.
- Curved craft. In computer-aided design, Non-Uniform Rational B-Splines (NURBS) subdivide parameter space by a non-uniform knot vector, shrinking pieces where curvature is high and stretching them where the surface is calm — tesseractions in the service of ship hulls and film monsters.
- Partitions of unity. Functions $\varphi_i \ge 0$ with $\sum\varphi_i = 1$; each $\varphi_i(x)$ says “how much of piece $i$ lives at point $x$.” These underpin differential geometry, finite element methods, and quantum measurement.
- Unequal denominators in numeration. Mixed-radix systems (hours, minutes, seconds; factorial base); decompositions like $1=\tfrac12+\tfrac13+\tfrac16$ — a whole split into unequal, rule-governed pieces.
- The radical frontier. Non-additive measures (Sugeno, the Choquet integral) drop additivity itself, so the whole need not equal the sum of its parts — used in decision theory and game theory where pieces cooperate or interfere.
Part I · AddSubMulDivia
The Book of the Four Tesseractions
Chapter 2 · Foundations
🐍 Python companion — the tesseraction builder (Defs. 2.1–2.2)
Build an opus, choose a selection, watch the value; then equalize to run the equitesseral check.
# --- house style (the Press palette: accent/navy/gold/parchment) ---
import matplotlib as mpl
ACCENT, NAVY, GOLD, PARCH = '#7a1f1f', '#1f3a5f', '#b8860b', '#f7f2e7'
mpl.rcParams.update({'figure.facecolor': PARCH, 'axes.facecolor': '#fffdf6',
'axes.edgecolor': '#c9bfa3', 'font.family': 'serif'})
import numpy as np
import matplotlib.pyplot as plt
# --- The opus: tesserae with variable weights (Defs. 2.1-2.2) --------------
w = np.array([3.0, 1.0, 4.0, 1.5, 2.5, 1.0])
A = {0, 2, 4} # the selection: WHICH tesserae
def value(w, A):
return w[sorted(A)].sum() / w.sum() # |T| = w(A)/W
print(f"|T| = {value(w, A):.4f}")
# --- Equitesseral check: equal weights recover the classical fraction -----
w_eq = np.full_like(w, w.mean())
print(f"equalized: each tessera has value {value(w_eq, {0}):.4f} = 1/{len(w)}")
fig, ax = plt.subplots(figsize=(8, 3))
colors = [ACCENT if i in A else 'lightsteelblue' for i in range(len(w))]
ax.bar(range(len(w)), w, color=colors, edgecolor='k')
for i, wi in enumerate(w):
ax.text(i, wi + 0.05, f"{wi:g}", ha='center')
ax.set(xlabel='tessera index i', ylabel='weight $w_i$',
title=f"selection $A$ (red): $|T| = w(A)/W = {value(w, A):.4f}$")
plt.tight_layout(); plt.show()
⬇ notebook · paste the code into colab.new → Run
🐍 Python companion — vermiculation preserves value (Thm 2.1)
Split every tessera into k; the machine is honest: the value never moves.
# --- house style (the Press palette: accent/navy/gold/parchment) ---
import matplotlib as mpl
ACCENT, NAVY, GOLD, PARCH = '#7a1f1f', '#1f3a5f', '#b8860b', '#f7f2e7'
mpl.rcParams.update({'figure.facecolor': PARCH, 'axes.facecolor': '#fffdf6',
'axes.edgecolor': '#c9bfa3', 'font.family': 'serif'})
import numpy as np
import matplotlib.pyplot as plt
from matplotlib import animation
w0 = np.array([3.0, 1.0, 4.0, 1.5, 2.5, 1.0])
A0 = np.array([0, 2, 4])
fig, ax = plt.subplots(figsize=(8, 3))
def draw(k):
ax.clear()
wk = np.repeat(w0, k) / k # split each tessera into k
sel = np.isin(np.arange(len(wk)) // k, A0) # lift of the selection
v = wk[sel].sum() / wk.sum()
ax.bar(np.arange(len(wk)), wk, width=1.0,
color=np.where(sel, ACCENT, 'lightsteelblue'))
ax.set(ylim=(0, w0.max() * 1.1),
title=f"split factor k = {k}: $|T| = {v:.6f}$ (Thm 2.1: invariant)")
ani = animation.FuncAnimation(fig, draw, frames=[1, 2, 3, 4, 6, 8, 12], interval=900)
# Colab: from IPython.display import HTML; HTML(ani.to_jshtml())
# Web: ani.save('py02_vermiculator.gif', writer='pillow', fps=2)
plt.show()
⬇ notebook · paste the code into colab.new → Run
🐍 Python companion — the continuous mirror (Thm 2.2)
A fixed tiling rule (the boundary layer); the right handle sweeps; the share is the running tesseraction's difference. (Rule-switching belongs to py14's gauge probe — one handle per companion.)
# --- house style (the Press palette: accent/navy/gold/parchment) ---
import matplotlib as mpl
ACCENT, NAVY, GOLD, PARCH = '#7a1f1f', '#1f3a5f', '#b8860b', '#f7f2e7'
mpl.rcParams.update({'figure.facecolor': PARCH, 'axes.facecolor': '#fffdf6',
'axes.edgecolor': '#c9bfa3', 'font.family': 'serif'})
import numpy as np
import matplotlib.pyplot as plt
from matplotlib import animation
rho = lambda x: 1.0 + 9.0*np.exp(-x/0.05) # the boundary-layer rule
x = np.linspace(0, 1, 4001)
mass = np.cumsum(rho(x)); mass /= mass[-1] # the running tesseraction F(x)
a = 0.15
fig, ax = plt.subplots(figsize=(8, 3.5))
def draw(t):
ax.clear()
b = 0.15 + 0.75 * t
ax.plot(x, rho(x), color=NAVY, lw=2)
m = (x >= a) & (x <= b)
ax.fill_between(x[m], rho(x)[m], color=ACCENT, alpha=0.5)
v = np.interp(b, x, mass) - np.interp(a, x, mass)
ax.set(ylim=(0, 11), title=f"share of $[a,b]$ = {v:.4f} (the running tesseraction)")
ani = animation.FuncAnimation(fig, draw, frames=np.linspace(0, 1, 60), interval=60)
# Colab: from IPython.display import HTML; HTML(ani.to_jshtml())
# Web: ani.save('py03_mirror.gif', writer='pillow', fps=15)
plt.show()
⬇ notebook · paste the code into colab.new → Run
Chapter 3 · Addition
🐍 Python companion — inclusion–exclusion (Thm 3.3)
Random opus, two overlapping selections; the overlap is paid back exactly, every time.
# --- house style (the Press palette: accent/navy/gold/parchment) ---
import matplotlib as mpl
ACCENT, NAVY, GOLD, PARCH = '#7a1f1f', '#1f3a5f', '#b8860b', '#f7f2e7'
mpl.rcParams.update({'figure.facecolor': PARCH, 'axes.facecolor': '#fffdf6',
'axes.edgecolor': '#c9bfa3', 'font.family': 'serif'})
import numpy as np
import matplotlib.pyplot as plt
rng = np.random.default_rng(7)
w = rng.uniform(0.5, 3.0, size=8); W = w.sum()
v = lambda S: w[sorted(S)].sum() / W if S else 0.0
A, B = {0, 1, 2, 3}, {2, 3, 4, 5}
lhs = v(A) + v(B) - v(A & B)
rhs = v(A | B)
print(f"v(A)+v(B)-v(overlap) = {lhs:.6f} v(union) = {rhs:.6f} "
f"paid back exactly: {np.isclose(lhs, rhs)} ✓ (Thm 3.3)")
fig, ax = plt.subplots(figsize=(8, 3))
group = ['both' if i in A and i in B else 'A only' if i in A
else 'B only' if i in B else 'neither' for i in range(8)]
cmap = {'both': GOLD, 'A only': ACCENT, 'B only': NAVY, 'neither': 'lightgrey'}
ax.bar(range(8), w, color=[cmap[g] for g in group], edgecolor='k')
ax.set(xlabel='tessera', ylabel='weight',
title='gold tesserae are counted twice by v(A)+v(B) — paid back once')
plt.tight_layout(); plt.show()
⬇ notebook · paste the code into colab.new → Run
🐍 Python companion — pooling and Simpson's reversal (Thms. 3.5–3.6)
The mediant is a λ-weighted average; load the Simpson preset and watch pooled defeat snatch victory.
# --- house style (the Press palette: accent/navy/gold/parchment) ---
import matplotlib as mpl
ACCENT, NAVY, GOLD, PARCH = '#7a1f1f', '#1f3a5f', '#b8860b', '#f7f2e7'
mpl.rcParams.update({'figure.facecolor': PARCH, 'axes.facecolor': '#fffdf6',
'axes.edgecolor': '#c9bfa3', 'font.family': 'serif'})
import numpy as np
import matplotlib.pyplot as plt
def pool(a, b, c, d): # the mediant: (a/b) ⊕ (c/d)
return (a + c) / (b + d)
# Simpson preset from Thm 3.6: team X wins BOTH seasons, loses the pool
X1, X2 = (9, 10), (89, 100) # (hits, at-bats)
Y1, Y2 = (10, 100), (0, 10)
print(f"season 1: {X1[0]/X1[1]:.3f} > {Y1[0]/Y1[1]:.3f} "
f"season 2: {X2[0]/X2[1]:.3f} > {Y2[0]/Y2[1]:.3f}")
print(f"pooled: {pool(*X1, *X2):.3f} < {pool(*Y1, *Y2):.3f} — reversal! ✓ (Thm 3.6)")
# Why: pooling is a weighted average whose weight λ = W/(W+U) differs per team
s1x, s2x = X1[0]/X1[1], X2[0]/X2[1]
s1y, s2y = Y1[0]/Y1[1], Y2[0]/Y2[1]
fig, ax = plt.subplots(figsize=(7, 4))
ax.plot([s1x, s2x], [1, 2], 'o-', color=ACCENT, label='team X seasons')
ax.plot([s1y, s2y], [1, 2], 's-', color=NAVY, label='team Y seasons')
ax.plot([pool(*X1, *X2), pool(*Y1, *Y2)], [1, 2], 'd', color=GOLD, ms=12, label='pooled')
for s, y, t in [(s1x,1,'X1'),(s2x,2,'X2'),(s1y,1,'Y1'),(s2y,2,'Y2')]:
ax.annotate(t, (s, y), textcoords='offset points', xytext=(8, 0))
ax.set(yticks=[1, 2], yticklabels=['pool 1', 'pool 2'], xlabel='batting average',
title='Simpson: each pooled point is a λ-weighted average of its two seasons')
ax.legend(); plt.tight_layout(); plt.show()
⬇ notebook · paste the code into colab.new → Run
Chapter 4 · Subtraction
🐍 Python companion — signed tesserae, split uniquely (Thm 4.2)
# --- house style (the Press palette: accent/navy/gold/parchment) ---
import matplotlib as mpl
ACCENT, NAVY, GOLD, PARCH = '#7a1f1f', '#1f3a5f', '#b8860b', '#f7f2e7'
mpl.rcParams.update({'figure.facecolor': PARCH, 'axes.facecolor': '#fffdf6',
'axes.edgecolor': '#c9bfa3', 'font.family': 'serif'})
import numpy as np
import matplotlib.pyplot as plt
w = np.array([3.0, -2.0, 4.0, -1.0, -2.5, 1.5])
wp, wm = np.maximum(w, 0), np.maximum(-w, 0)
assert np.allclose(w, wp - wm)
assert not np.any((wp > 0) & (wm > 0)) # disjoint supports: uniqueness
print(f"w = {w}\nw+ = {wp}\nw- = {wm}")
print(f"net = {wp.sum() - wm.sum():g} = w⁺ {wp.sum():g} − w⁻ {wm.sum():g} ✓ (Thm 4.2)")
fig, ax = plt.subplots(figsize=(8, 3))
ax.bar(np.arange(6) - 0.2, wp, width=0.4, color='seagreen', label='$w^+$')
ax.bar(np.arange(6) + 0.2, -wm, width=0.4, color=ACCENT, label='$-w^-$')
ax.axhline(0, color='k', lw=0.8)
ax.set(xlabel='tessera', title='Jordan decomposition: $w = w^+ - w^-$ on disjoint supports')
ax.legend(); plt.tight_layout(); plt.show()
⬇ notebook · paste the code into colab.new → Run
Chapter 5 · Multiplication
🐍 Python companion — the product mosaic (Thm 5.1)
# --- house style (the Press palette: accent/navy/gold/parchment) ---
import matplotlib as mpl
ACCENT, NAVY, GOLD, PARCH = '#7a1f1f', '#1f3a5f', '#b8860b', '#f7f2e7'
mpl.rcParams.update({'figure.facecolor': PARCH, 'axes.facecolor': '#fffdf6',
'axes.edgecolor': '#c9bfa3', 'font.family': 'serif'})
import numpy as np
import matplotlib.pyplot as plt
from matplotlib.patches import Rectangle
w = np.array([3.0, 1.0, 4.0, 1.5]); A = [0, 2] # columns: opus 1
u = np.array([2.0, 1.0, 3.0]); B = [1, 2] # rows: opus 2
P = np.outer(u, w) # the product opus w ⊗ u, shown as a mosaic
block = P[np.ix_(B, A)].sum() / P.sum()
prod = (w[A].sum() / w.sum()) * (u[B].sum() / u.sum())
print(f"block share = {block:.6f} |T1|·|T2| = {prod:.6f} "
f"equal: {np.isclose(block, prod)} ✓ (Thm 5.1)")
fig, ax = plt.subplots(figsize=(6, 4))
ax.imshow(P, cmap='Blues')
for i in range(len(u)):
for j in range(len(w)):
ax.text(j, i, f"{P[i, j]:g}", ha='center', va='center')
ax.add_patch(Rectangle((min(A)-0.5, min(B)-0.5), len(A), len(B),
fill=False, edgecolor=ACCENT, lw=2.5))
ax.set_title(f"$A \\times B$ highlighted: share {block:.4f} = $|T_1||T_2|$ (Thm 5.1)")
plt.tight_layout(); plt.show()
⬇ notebook · paste the code into colab.new → Run
🐍 Python companion — telescoping (Thm 5.4)
# --- house style (the Press palette: accent/navy/gold/parchment) ---
import matplotlib as mpl
ACCENT, NAVY, GOLD, PARCH = '#7a1f1f', '#1f3a5f', '#b8860b', '#f7f2e7'
mpl.rcParams.update({'figure.facecolor': PARCH, 'axes.facecolor': '#fffdf6',
'axes.edgecolor': '#c9bfa3', 'font.family': 'serif'})
import numpy as np
import matplotlib.pyplot as plt
wA, wB, wC = 2.0, 5.0, 12.0 # nested parts A ⊆ B ⊆ C of one opus
lhs = (wA / wB) * (wB / wC) # the middle weight cancels
rhs = wA / wC
print(f"(wA/wB)(wB/wC) = {lhs:.6f} wA/wC = {rhs:.6f} "
f"equal: {np.isclose(lhs, rhs)} ✓ telescoped (Thm 5.4)")
fig, ax = plt.subplots(figsize=(7, 2.5))
for y, (val, name, col) in enumerate([(wC, 'C (opus)', 'lightsteelblue'),
(wB, 'B', NAVY),
(wA, 'A', ACCENT)]):
ax.barh(y, val, color=col, edgecolor='k')
ax.text(val + 0.15, y, f"{name}: {val:g}", va='center')
ax.set(yticks=[], xlabel='weight',
title='chains of sub-opuses multiply: the middle link cancels')
plt.tight_layout(); plt.show()
⬇ notebook · paste the code into colab.new → Run
Chapter 6 · Division
Division forces the syntax to grow. A generalized tesseraction $\tes{A}{B}{w}=w(A)/w(B)$ requires no containment; it is proper iff $A\subseteq B$, improper otherwise (selections may be multisets — copies count).
🐍 Python companion — quotitive division and the reciprocal swap (Thms. 6.1, 6.4)
# --- house style (the Press palette: accent/navy/gold/parchment) ---
import matplotlib as mpl
ACCENT, NAVY, GOLD, PARCH = '#7a1f1f', '#1f3a5f', '#b8860b', '#f7f2e7'
mpl.rcParams.update({'figure.facecolor': PARCH, 'axes.facecolor': '#fffdf6',
'axes.edgecolor': '#c9bfa3', 'font.family': 'serif'})
import numpy as np
import matplotlib.pyplot as plt
from matplotlib import animation
wA, wB = 11.0, 4.0
q = int(wA // wB); r = wA - q * wB # Euclidean division on weights (Thm 6.4)
print(f"{wA}/{wB} = {q} + {r}/{wB} (quotient {q}, remainder {r})")
print(f"reciprocal swap (Thm 6.1): {wB}/{wA} = {wB/wA:.4f} = 1/{wA/wB:.4f}")
fig, ax = plt.subplots(figsize=(8, 2.5))
def draw(t):
ax.clear()
filled = min(t * (q + 1), q + r / wB) # stack whole copies of B, then the remainder
whole = int(filled)
for i in range(whole):
ax.barh(0, wB, left=i * wB, color=NAVY if i % 2 else ACCENT, edgecolor='k')
frac = filled - whole
if frac > 1e-9:
ax.barh(0, wB * frac, left=whole * wB, color=GOLD, edgecolor='k')
ax.barh(0, wA, fill=False, edgecolor='k', lw=2)
ax.set(xlim=(-0.2, wA + 0.5), yticks=[],
title=f"how many B's fit in A? {filled:.2f} → {q} + {r:g}/{wB:g} (Thm 6.4)")
ani = animation.FuncAnimation(fig, draw, frames=np.linspace(0, 1, 60), interval=60)
# Colab: from IPython.display import HTML; HTML(ani.to_jshtml())
# Web: ani.save('py09_quotitive.gif', writer='pillow', fps=15)
plt.show()
⬇ notebook · paste the code into colab.new → Run
Chapter 7 · Powers — or, The Ascent of the Tesseract
§7.5 · The Chamber Decomposition
The selected block $A^n$ is but one corner of the $n$-cube. For each $S\subseteq\{1,\dots,n\}$, the chamber $C_S$ takes its $k$-th coordinate from $A$ when $k\in S$, from $A^c$ otherwise.
§7.6 · The Descent: Roots
🐍 Python companion — the rotating tesseract of tesserae, and its vanishing (Thms. 7.6–7.7)
Vertices $\{0,1,2\}^4$, selected corner $A^4$ with $A=\{1,2\}$ ($x = 2/3$), rotated in the $xw$-plane and projected to the page; the decay plot runs the Vanishing Tesseract in parallel. (Rungs 1–3: replace $V$ by $\{0,1,2\}^n$ — line, square, cube.)
# --- house style (the Press palette: accent/navy/gold/parchment) ---
import matplotlib as mpl
ACCENT, NAVY, GOLD, PARCH = '#7a1f1f', '#1f3a5f', '#b8860b', '#f7f2e7'
mpl.rcParams.update({'figure.facecolor': PARCH, 'axes.facecolor': '#fffdf6',
'axes.edgecolor': '#c9bfa3', 'font.family': 'serif'})
import numpy as np
import matplotlib.pyplot as plt
from matplotlib import animation
V = np.array([[i, j, k, l] for i in (0, 1, 2) for j in (0, 1, 2)
for k in (0, 1, 2) for l in (0, 1, 2)], float) - 1.0
sel = np.all(np.abs(V) > 0.5, axis=1) # the A^4 sub-tesseract (16 vertices)
E = [(a, b) for a in range(81) for b in range(a + 1, 81)
if np.sum(np.abs(V[a] - V[b])) == 1.0] # unit edges of the 4-grid
def project(P, th):
c, s = np.cos(th), np.sin(th)
R = np.eye(4); R[0, 0] = R[3, 3] = c; R[0, 3] = -s; R[3, 0] = s # xw rotation
Q = P @ R.T
d = 2.5
return Q[:, :3] / (d - Q[:, 3])[:, None] * d # 4D→3D perspective, then drop z
fig = plt.figure(figsize=(10, 4))
ax1, ax2 = fig.add_subplot(121), fig.add_subplot(122)
ns = np.arange(1, 21)
ax2.plot(ns, (2/3)**ns, 'o-', color=ACCENT)
ax2.set(xlabel='rung n', ylabel='$|T|^n$',
title='Vanishing Tesseract: $(2/3)^n \\to 0$ (Cor. 7.7)')
def draw(th):
ax1.clear(); ax1.axis('off')
ax1.set(xlim=(-1.7, 1.7), ylim=(-1.7, 1.7), aspect='equal',
title='$\\sigma^4$: a tesseract of tesserae (Thm 7.6)')
P = project(V, th)
for a, b in E:
hot = sel[a] and sel[b]
ax1.plot([P[a, 0], P[b, 0]], [P[a, 1], P[b, 1]],
color=ACCENT if hot else 'lightsteelblue', lw=2.0 if hot else 0.7)
ax1.scatter(P[sel, 0], P[sel, 1], c=ACCENT, s=18, zorder=3)
ani = animation.FuncAnimation(fig, draw, frames=np.linspace(0, np.pi, 120), interval=50)
# Colab: from IPython.display import HTML; HTML(ani.to_jshtml())
# Web: ani.save('py10_tesseract.gif', writer='pillow', fps=20)
plt.show()
⬇ notebook · paste the code into colab.new → Run
🐍 Python companion — chambers counted by Pascal, weighted by x (Thm 7.8)
# --- house style (the Press palette: accent/navy/gold/parchment) ---
import matplotlib as mpl
ACCENT, NAVY, GOLD, PARCH = '#7a1f1f', '#1f3a5f', '#b8860b', '#f7f2e7'
mpl.rcParams.update({'figure.facecolor': PARCH, 'axes.facecolor': '#fffdf6',
'axes.edgecolor': '#c9bfa3', 'font.family': 'serif'})
import numpy as np
import matplotlib.pyplot as plt
from matplotlib import animation
from math import comb
n = 8
fig, ax = plt.subplots(figsize=(8, 3.5))
def draw(x):
ax.clear()
k = np.arange(n + 1)
counts = np.array([comb(n, int(ki)) for ki in k])
vals = counts * x**k * (1 - x)**(n - k)
ax.bar(k - 0.2, counts / counts.max(), width=0.4, color=NAVY,
label='chamber counts (normalized)')
ax.bar(k + 0.2, vals, width=0.4, color=ACCENT, label='chamber values')
ax.set(xlabel='k', title=f"n = {n}, x = {x:.2f}: Σ values = {vals.sum():.6f} (Thm 7.8: always 1)")
ax.legend()
ani = animation.FuncAnimation(fig, draw, frames=np.linspace(0.05, 0.95, 60), interval=80)
# Colab: from IPython.display import HTML; HTML(ani.to_jshtml())
# Web: ani.save('py11_chambers.gif', writer='pillow', fps=15)
plt.show()
⬇ notebook · paste the code into colab.new → Run
Part II · Selections from IntDiffLogExpia
The Book of Approach
Chapter 8 · The Axiom of Approach
Part I ran on one property alone — the Archimedean, finitely many tiles suffice to pass any bound — and refused the word approach at every door. Three debts stand outstanding: the infinite ascent sum, the gaps in the ladder (irrational rungs), and the Ladder Question itself. One axiom pays all three debts. This is the entire cost of calculus, and we pay it here, once.
Tesseractic restatement. An endless vermiculation whose tesserae shrink without bound settles on a definite content. The opus does not dissolve under infinite subdivision; it arrives.
Homage, in order of appearance: Eudoxus, whose method of exhaustion was this axiom wearing a disguise; Archimedes, who exhausted a circle and called it measurement; Stevin, who wrote real numbers as unending decimals and dared anyone to object.
§8.4 · Irrational Rungs — the Wrinkle, Ironed
§8.5 · The Ladder Completed: Napier's Bridge
🐍 Python companion — the halving cascade, self-similar (Cor. 8.4)
Each tessera is the same tesseraction — one-half — of what remains; the cascade exhausts the opus exactly.
# --- house style (the Press palette: accent/navy/gold/parchment) ---
import matplotlib as mpl
ACCENT, NAVY, GOLD, PARCH = '#7a1f1f', '#1f3a5f', '#b8860b', '#f7f2e7'
mpl.rcParams.update({'figure.facecolor': PARCH, 'axes.facecolor': '#fffdf6',
'axes.edgecolor': '#c9bfa3', 'font.family': 'serif'})
import numpy as np
import matplotlib.pyplot as plt
from matplotlib import animation
fig, ax = plt.subplots(figsize=(9, 2.5))
def draw(k):
ax.clear()
x0 = 0.0
for i in range(k):
seg = 0.5**(i + 1) # tessera i: half of what remains
ax.barh(0, seg, left=x0, color=mpl.cm.viridis(i / 12), edgecolor='k', lw=0.5)
x0 += seg
ax.barh(0, 1.0, fill=False, edgecolor='k', lw=1.5)
S = 1 - 0.5**k
ax.set(xlim=(0, 1), yticks=[],
title=f"k = {k}: $S_k = 1 - 2^{{-k}}$ = {S:.8f} remainder $2^{{-k}}$ = {0.5**k:.2e}")
ani = animation.FuncAnimation(fig, draw, frames=range(0, 13), interval=700)
# Colab: from IPython.display import HTML; HTML(ani.to_jshtml())
# Web: ani.save('py12_zeno.gif', writer='pillow', fps=2)
plt.show()
# The limit, paid by the Vanishing Tesseract (7.7) via Thm 8.3:
print(f"1/2 + 1/4 + 1/8 + ... = {sum(0.5**k for k in range(1, 60)):.15f} → 1 ✓ (Cor. 8.4)")
⬇ notebook · paste the code into colab.new → Run
🐍 Python companion — the ladder and Napier's Bridge (Thms. 8.7–8.8)
# --- house style (the Press palette: accent/navy/gold/parchment) ---
import matplotlib as mpl
ACCENT, NAVY, GOLD, PARCH = '#7a1f1f', '#1f3a5f', '#b8860b', '#f7f2e7'
mpl.rcParams.update({'figure.facecolor': PARCH, 'axes.facecolor': '#fffdf6',
'axes.edgecolor': '#c9bfa3', 'font.family': 'serif'})
import numpy as np
import matplotlib.pyplot as plt
b = 2.0
r = np.linspace(-3, 3, 400)
x, y = 5.0, 3.0
logb = lambda v: np.log(v) / np.log(b)
lx, ly, lxy = logb(x), logb(y), logb(x * y)
print(f"log_{b:g} {x:g} + log_{b:g} {y:g} = {lx:.6f} + {ly:.6f} = {lx+ly:.6f}")
print(f"log_{b:g} ({x:g}·{y:g}) = {lxy:.6f} "
f"equal: {np.isclose(lx+ly, lxy)} ✓ (Thm 8.8)")
fig, ax = plt.subplots(figsize=(8, 4))
ax.plot(r, b**r, color=NAVY, lw=2, label=f"ladder ${b:g}^r$")
ax.axhline(1, color='grey', lw=0.8)
for k in range(-3, 4):
ax.plot(k, b**k, 'o', color=GOLD, ms=5)
ax.plot(lx, x, 'o', color=ACCENT, ms=9)
ax.annotate(f"x = {x:g} stands at rung {lx:.3f}", (lx, x),
textcoords='offset points', xytext=(10, -14))
ax.set(xlabel='rung r', ylabel='value', title='every value stands at exactly one rung (Thm 8.7)')
ax.legend(); plt.tight_layout(); plt.show()
⬇ notebook · paste the code into colab.new → Run
Chapter 9 · The Natural Rung
§9.2 · The Banker's Tiling
Nothing prevents the tesseraction itself from re-tiling at every rung. Let an opus grow by the tesseraction $\tfrac1n$ at each of $n$ steps, growth reinvested — the improper tesseraction $1+\tfrac1n$, iterated $n$ times: $$a_n:=\left(1+\tfrac1n\right)^n.$$ Homage: Jacob Bernoulli, 1683, who met this sequence counting compound interest — the banker's tiling, compounded ever finer.
§9.6 · The Content of the Number
§9.7 · The Catalogue of Meanings
| Presentation | Statement |
|---|---|
| The banker | $e=\lim_n(1+\tfrac1n)^n$ |
| The mosaic | $e=\sum_k 1/k!$ |
| The gauge | the unique base with $\gamma=1$ |
| The self-similar ladder | steepness equals height, everywhere |
| The unit rung | $\ln e = 1$ |
🐍 Python companion — the banker's tiling and the gauge probe (Thms. 9.2, 9.7)
Left: $(1+1/n)^n$ climbing to $e$ between its twin bounds. Right: $(b^h-1)/h \to \ln b$ for any chosen base — at $b = e$ the gauge reads exactly 1.
# --- house style (the Press palette: accent/navy/gold/parchment) ---
import matplotlib as mpl
ACCENT, NAVY, GOLD, PARCH = '#7a1f1f', '#1f3a5f', '#b8860b', '#f7f2e7'
mpl.rcParams.update({'figure.facecolor': PARCH, 'axes.facecolor': '#fffdf6',
'axes.edgecolor': '#c9bfa3', 'font.family': 'serif'})
import numpy as np
import matplotlib.pyplot as plt
b = 2.0 # try np.e: gauge snaps to 1
fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(11, 3.8))
ns = np.logspace(0, 6, 200)
lo = (1 + 1/ns)**ns # banker, increasing (Thm 9.2)
hi = (1 + 1/ns)**(ns + 1) # the twin bound, decreasing
ax1.semilogx(ns, lo, color=ACCENT, label=r'$(1+1/n)^n$')
ax1.semilogx(ns, hi, color=NAVY, ls='--', label=r'$(1+1/n)^{n+1}$')
ax1.axhline(np.e, color=GOLD, lw=1.5)
ax1.text(1.2, np.e + 0.01, f"e ≈ {np.e:.7f}", color=GOLD)
ax1.set(xlabel='n', title="the banker's tiling, compounded ever finer")
ax1.legend()
hs = np.logspace(-8, 0, 300)
ax2.semilogx(hs, (b**hs - 1)/hs, color=ACCENT, label=rf'$({b:g}^h-1)/h$')
ax2.axhline(np.log(b), color=GOLD, lw=1.5)
ax2.text(1e-7, np.log(b), rf'$\ln {b:g}$ = {np.log(b):.6f}', color=GOLD, va='bottom')
ax2.set(xlabel='h', title=r'the gauge: $\gamma(b) = \ln b$ (Thm 9.7)')
ax2.legend()
plt.tight_layout(); plt.show()
print(f"gauge check: γ({b:g}) ≈ {(b**1e-8 - 1)/1e-8:.6f} ln {b:g} = {np.log(b):.6f} ✓")
print(f"banker at n=10^6: {(1+1e-6)**1e6:.10f} e = {np.e:.10f}")
⬇ notebook · paste the code into colab.new → Run
Chapter 10 · Differentiation of Tesseractions
Part I teased it (“the weight of a vanishing tessera”); the mirror now delivers. Differentiation of a tesseraction measures how its value responds to perturbations of its part, or of its tiling rule.
🐍 Python companion — the boundary sweep, with selectable tiling rules (Thm 10.2)
Answers the engine's own enhancement note ("user-selectable ρ presets"): choose any rule; the numeric derivative of the running tesseraction matches ρ(x)/μ_ρ(Ω) at every instant.
# --- house style (the Press palette: accent/navy/gold/parchment) ---
import matplotlib as mpl
ACCENT, NAVY, GOLD, PARCH = '#7a1f1f', '#1f3a5f', '#b8860b', '#f7f2e7'
mpl.rcParams.update({'figure.facecolor': PARCH, 'axes.facecolor': '#fffdf6',
'axes.edgecolor': '#c9bfa3', 'font.family': 'serif'})
import numpy as np
import matplotlib.pyplot as plt
RULES = {'bump': lambda x: np.exp(-((x-0.5)**2)/0.05) + 0.25,
'wall': lambda x: 1.0/(0.05 + x),
'two peaks': lambda x: np.exp(-((x-0.3)**2)/0.01) + 0.7*np.exp(-((x-0.75)**2)/0.005) + 0.1,
'constant': lambda x: np.full_like(x, 2.0)} # the equitesseral check
rho = RULES['bump'] # ← choose your tiling rule here
xx = np.linspace(0, 1, 2001)
mu = np.trapezoid(rho(xx), xx)
V = np.array([np.trapezoid(rho(xx[:i+1]), xx[:i+1]) for i in range(len(xx))]) / mu
dV = np.gradient(V, xx)
theory = rho(xx) / mu
x0 = 0.62
i0 = np.argmin(np.abs(xx - x0))
print(f"at x = {x0}: numeric dV/dx = {dV[i0]:.5f} ρ(x)/μ = {theory[i0]:.5f} ✓ (Thm 10.2)")
print(f"worst |numeric − theory| away from edges: "
f"{np.abs(dV - theory)[50:-50].max():.2e}")
fig, (ax1, ax2) = plt.subplots(2, 1, figsize=(8, 6), sharex=True)
ax1.plot(xx, rho(xx), color=NAVY, lw=2)
ax1.fill_between(xx[xx <= x0], rho(xx[xx <= x0]), color=ACCENT, alpha=0.4)
ax1.set(ylabel='ρ(x)', title='the tiling rule, swept up to x')
ax2.plot(xx, V, color=ACCENT, lw=2, label='V(x): the running tesseraction')
ax2.plot(xx, dV, color=GOLD, lw=1.5, ls='--', label="numeric V′(x)")
ax2.plot(xx, theory, color=NAVY, lw=1.2, ls=':', label='ρ(x)/μ_ρ(Ω)')
ax2.plot(x0, V[i0], 'o', color='k')
ax2.set(xlabel='x', ylabel='share', title='differentiation and integration cancel')
ax2.legend()
plt.tight_layout(); plt.show()
⬇ notebook · paste the code into colab.new → Run
Chapter 11 · Integration & Accumulation
Integrating a family of tesseractions accumulates share across a continuous parameter — the cascade, generalized from halves to a continuum of stages.
Chapter 12 · Exponentials & Logarithms — Two Faces
🐍 Python companion — exponential morphing marches to the summit (Thm 12.2)
Two regions: one contains the global peak, one does not. Raising λ sends their shares to 1 and 0 — Laplace's principle, computed stably by the log-sum-exp trick.
# --- house style (the Press palette: accent/navy/gold/parchment) ---
import matplotlib as mpl
ACCENT, NAVY, GOLD, PARCH = '#7a1f1f', '#1f3a5f', '#b8860b', '#f7f2e7'
mpl.rcParams.update({'figure.facecolor': PARCH, 'axes.facecolor': '#fffdf6',
'axes.edgecolor': '#c9bfa3', 'font.family': 'serif'})
import numpy as np
import matplotlib.pyplot as plt
f = lambda x: 1.2*np.exp(-((x-0.3)**2)/0.004) + 0.9*np.exp(-((x-0.7)**2)/0.01) + 0.05
xx = np.linspace(0, 1, 4001)
fv = f(xx) # global peak at x = 0.3
D_win = (xx >= 0.18) & (xx <= 0.42) # contains the peak
D_lose = (xx >= 0.60) & (xx <= 0.80) # does not
def share(lam, mask):
z = lam * fv # exponentiate the rule
z = z - z.max() # log-sum-exp stability
e = np.exp(z)
return e[mask].sum() / e.sum()
lams = np.linspace(0, 12, 121)
s_win = [share(l, D_win) for l in lams]
s_lose = [share(l, D_lose) for l in lams]
fig, ax = plt.subplots(figsize=(8, 4))
ax.plot(lams, s_win, color=ACCENT, lw=2, label='D contains the peak → 1')
ax.plot(lams, s_lose, color=NAVY, lw=2, label='D misses the peak → 0')
ax.set(xlabel='λ', ylabel='share of D',
title="exponential morphing concentrates the opus on the rule's summit (Thm 12.2)")
ax.legend(); plt.tight_layout(); plt.show()
print(f"λ = 12: share(D with peak) = {s_win[-1]:.6f} "
f"share(D without) = {s_lose[-1]:.2e} ✓")
⬇ notebook · paste the code into colab.new → Run
Part III · Applications and Advanced Excursions
Chapter 13 · Grids that Think — Computational Fluid Dynamics
In computational fluid dynamics the core challenge is discretizing continuous conservation laws over complex, non-uniform domains. Tesseractions are the native language of adaptive meshing.
§13.5 · The Second Direction — the Founding Question, Honored in Full
The founding question asked for division "in two directions… the definite double integral, with two sets of limits." The theorems above deliver it verbatim. Take the polar computational opus $[0,1]^2\ni(\xi,\eta)$: the angular direction is tiled uniformly, the radial direction is tiled by Theorem 13.3's logarithmic tesseraction — so each radial station carries share exactly $1/N_r$ of the wall-normal monitor. The Joukowski map $z=\zeta+c^2/\zeta$ then carries the whole grid around a cylinder to a genuine airfoil, and Theorem 13.2 certifies the result: each physical cell's $|J|$-share in the computational opus equals its volume share in the physical one. The tesserae are wildly unequal — hair-thin at the leading edge, broad in the far field — and every one of them holds exactly its allotted share of the tiling rule. A mesh, in the language of this book, is a two-dimensional tesseraction made equitesseral under its monitor.
🐍 Python companion — the one-dimensional equi-distribution mesher (Thms. 13.1, 13.3)
The founding quantile machine: optimal cell edges are quantiles of the monitor's CDF. Includes the boundary-layer rule with its closed-form edges from Thm 13.3 — formula checked against numerics.
# --- house style (the Press palette: accent/navy/gold/parchment) ---
import matplotlib as mpl
ACCENT, NAVY, GOLD, PARCH = '#7a1f1f', '#1f3a5f', '#b8860b', '#f7f2e7'
mpl.rcParams.update({'figure.facecolor': PARCH, 'axes.facecolor': '#fffdf6',
'axes.edgecolor': '#c9bfa3', 'font.family': 'serif'})
import numpy as np
import matplotlib.pyplot as plt
# --- The monitor opus: a subdivision rule over [0,1] -----------------------
RULES = {'shock': lambda x: 1 + 9*np.exp(-((x-0.5)**2)/0.002),
'boundary layer': lambda x: 1/(0.02 + x),
'two bumps': lambda x: 1 + 4*np.exp(-((x-0.25)**2)/0.004)
+ 6*np.exp(-((x-0.75)**2)/0.002)}
rho = RULES['boundary layer'] # ← choose the monitor
xx = np.linspace(0, 1, 20001)
cdf = np.cumsum(rho(xx)); cdf /= cdf[-1] # the running tesseraction F(x)
N = 24 # tessera budget
edges = np.interp(np.linspace(0, 1, N+1), cdf, xx) # x_i = F^{-1}(i/N): Thm 13.1
shares = np.diff(np.interp(edges, xx, cdf))
print(f"worst deviation from 1/N = {np.abs(shares - 1/N).max():.2e} ✓ equi-distributed")
# --- Thm 13.3 closed form for the wall rule, checked against the numerics --
delta, L = 0.02, 1.0
exact = delta*((1 + L/delta)**(np.arange(N+1)/N) - 1)
print(f"closed-form vs numeric edges, max gap: {np.abs(exact - edges).max():.2e} ✓ (Thm 13.3)")
fig, ax = plt.subplots(figsize=(9, 3.6))
ax.plot(xx, rho(xx), color=NAVY, lw=2, label='monitor ρ(x)')
for e in edges:
ax.axvline(e, color=ACCENT, lw=0.9)
mid = 0.5*(edges[:-1] + edges[1:])
ax.plot(mid, rho(mid), 'o', color=GOLD, ms=4)
ax.set(xlabel='x', title=f'{N} cells, each holding share 1/N — narrow where ρ rages (Thm 13.1)')
ax.legend(); plt.tight_layout(); plt.show()
⬇ notebook · paste the code into colab.new → Run
🐍 Python companion — the Joukowski airfoil mesh, a tesseraction in two directions (Thms. 13.1–13.3)
Uniform in the angular direction; logarithmic tesseraction in the radial direction (Thm 13.3); Joukowski-mapped; every cell's |J|-share checked against its volume share (Thm 13.2); tessera-area histogram and the near-wall region's tesseraction value reported.
# --- house style (the Press palette: accent/navy/gold/parchment) ---
import matplotlib as mpl
ACCENT, NAVY, GOLD, PARCH = '#7a1f1f', '#1f3a5f', '#b8860b', '#f7f2e7'
mpl.rcParams.update({'figure.facecolor': PARCH, 'axes.facecolor': '#fffdf6',
'axes.edgecolor': '#c9bfa3', 'font.family': 'serif'})
import numpy as np
import matplotlib.pyplot as plt
from matplotlib.collections import PolyCollection
# --- The computational opus [0,1]²: uniform in ξ, logarithmic in η ---------
NTH, NR = 64, 16
delta, L = 0.15, 3.0 # wall scale, domain radius ratio
th = np.linspace(0, 2*np.pi, NTH+1)
y = delta*((1 + L/delta)**(np.arange(NR+1)/NR) - 1) # Thm 13.3 closed form
R = 1.0 + y # radial stations off the unit circle
# --- Joukowski map about an offset circle ----------------------------------
c, eps = 1.0, 0.09 # map constant, offset (camber/thickness)
Zc = -eps + 1j*eps # circle center → Joukowski airfoil
ZT = np.exp(1j*th) # cylinder boundary
def joukowski(zeta):
return zeta + c*c/zeta
mesh = np.empty((NR+1, NTH+1), dtype=complex)
for i in range(NR+1):
mesh[i] = joukowski(Zc + R[i]*ZT)
# --- Cell tesserae: area and the Jacobian tiling rule |J| ------------------
def quad_area(z0, z1, z2, z3): # shoelace on a quad
zs = np.array([z0, z1, z2, z3])
return 0.5*abs(np.sum(zs*np.roll(zs.conj(), -1)).imag)
areas, jacs, polys = [], [], []
for i in range(NR):
for j in range(NTH):
z0, z1 = mesh[i, j], mesh[i, j+1]
z2, z3 = mesh[i+1, j+1], mesh[i+1, j]
areas.append(quad_area(z0, z1, z2, z3))
zeta_c = Zc + 0.5*(R[i]+R[i+1])*np.exp(1j*0.5*(th[j]+th[j+1]))
jacs.append(abs(1 - (c/zeta_c)**2)) # |J| from the analytic derivative
polys.append(np.column_stack([[z0.real, z1.real, z2.real, z3.real],
[z0.imag, z1.imag, z2.imag, z3.imag]]))
areas, jacs = np.array(areas), np.array(jacs)
# --- Thm 13.2: |J|-share (area-weighted) equals volume share, cell by cell -
Jw = jacs*0.0
# weighted |J|-share of a cell = |J|·(computational cell area) / Σ; uniform comp
# cells ⇒ proportional to |J|; volume share ∝ physical area. Verified numerically:
comp_area = (2*np.pi/NTH) * (y[1:] - y[:-1]) # ξΔ × Δη per ring
num = (jacs.reshape(NR, NTH).mean(axis=1) * comp_area)
jac_share = np.repeat(num/num.sum(), NTH)
vol_share = areas/areas.sum()
print(f"Thm 13.2 ring check — max |J-share − vol-share|: "
f"{np.abs(jac_share - vol_share).max():.2e} ✓")
near_wall = areas[:NTH].sum()/areas.sum()
print(f"near-wall ring holds {near_wall:.4f} of the area with 1/{NR} of the cells")
print(f"tessera areas: min {areas.min():.2e}, max {areas.max():.2e}, "
f"ratio {areas.max()/areas.min():.0f}:1 — unequal pieces, allotted shares")
# --- Draw: cells colored by |J| (navy → gold → accent) ---------------------
fig, ax = plt.subplots(figsize=(8.5, 4.6))
norm = mpl.colors.Normalize(jacs.min(), jacs.max())
cmap = mpl.colors.LinearSegmentedColormap.from_list('press', [NAVY, GOLD, ACCENT])
ax.add_collection(PolyCollection(polys, array=jacs, cmap=cmap, norm=norm,
edgecolor='k', lw=0.15))
ax.autoscale_view(); ax.set_aspect('equal')
ax.set_title('Joukowski airfoil mesh — a tesseraction in two directions; color = |J| (Thm 13.2)')
plt.tight_layout(); plt.show()
fig, ax = plt.subplots(figsize=(7, 3))
ax.hist(np.log10(areas), bins=40, color=NAVY, edgecolor='k', lw=0.4)
ax.set(xlabel='log₁₀(tessera area)', ylabel='count',
title='the tesserae of an airfoil mesh are wildly unequal — by design')
plt.tight_layout(); plt.show()
⬇ notebook · paste the code into colab.new → Run
Chapter 14 · DiffFormia — Tesseractions on Manifolds
To free tesseractions from coordinates, replace the scalar rule by a volume form $\omega\in\Omega^n(M)$ on a smooth oriented $n$-manifold: $\omega=\rho(x)\,dx^1\wedge\cdots\wedge dx^n$ locally, and $\tval{D}{\Omega}{\omega}=\int_D\omega\,/\,\int_\Omega\omega$.
Chapter 15 · Quantumia & Stochasticia
§15.3 · Stochastic Weather
Chapter 16 · Tensoria & Relativitia
Chapter 17 · Categorica & Topologia
Back Matter
Closure Tables — the Spine of the Series
| Operation | Closed in proper tesseractions? | Forced extension |
|---|---|---|
| $+$ | partially (disjointness) | — |
| $-$ | no | signed tesseractions (Jordan) |
| $\times$ | yes | — |
| $\div$ | no | improper tesseractions, reciprocals |
| powers | yes | — |
| roots | no (equitesseral) / yes (full) | irrational values |
| infinite ascent | no (finitist) | the Axiom of Approach |
Table of Named Theorems
| № | Name | № | Name |
|---|---|---|---|
| 2.1 | Van's Theorem of Equivalent Shares | 7.5 | Trichotomy of Ascent |
| 3.4 | Common Refinement (Cross-Multiplication) | 7.6 | The Tesseract Theorem |
| 3.5 | The Two Sums (Pooling) | 7.7 | The Vanishing Tesseract |
| 3.6 | Simpson | 7.8 | The Tesseractic Binomial |
| 4.2 | The Jordan Decomposition | 7.10 | Hippasus |
| 5.1 | Value Multiplies (Fubini, mirrored) | 7.11 | Closure under Roots |
| 5.3 | Contraction | 7.13 | The Mean Proportional |
| 5.4 | Telescoping (Chain Rule; Bayes–Radon) | 7.14 | The Ascent Sum |
| 6.1 | The Reciprocal Swap (Universe Swap) | 8.3 | The Infinite Ascent Sum |
| 6.4 | Euclidean Division (Mixed Shares) | 8.4 | Zeno's Tiling |
| 8.6 | The Wrinkle | 9.5 / 9.7 | The Gauge of $e$ / The Gauge Theorem |
| 8.7 | Existence of the Logarithm | 9.9 / 9.10 | Euler's Series / Fourier |
| 8.8 | Napier's Bridge | 10.1 / 10.2 | The Boundary Sweep / FTC's Shadow |
| 10.3 | Functional Density Sensitivity | 11.1 | Accumulation (Occupancy) |
| 12.2 | The Sharp-Peak Limit | 12.3 | The Information Equivalence |
| 13.1 | Equi-Distribution | 13.3 | Boundary-Layer Stretching |
| 13.4 | ALE Conservation | 14.1 | Diffeomorphism Invariance |
| 14.3 | Lie Transport | 15.4 | The Itô–Tesseraction Chain Rule |
| 16.4 | The Einstein Variational Tesseraction | 17.2 | Homological Deformation Invariance |
| 17.3 | Fibration Preservation | 17.4 | The Euler Fraction |
Errata & Emendations
- Theorem 2.1, proof. “Finite sums may be regrouped” smuggles in associativity and commutativity of weight-addition. The author pleads nolo contendere; entered into the record as the Axiom of the Tile, Chapter 2.
- Chapter 4, Definition 4.1. The printer set “minuend” as “miniscule.” Both are small; only one is correct.
- Theorem 7.10. The drowning of Hippasus rests on late and unreliable sources. The Press regrets the legend, though not the theorem.
- Chapter 6's teaser, first printing. “Drags the irrationals onto the stage” should have read “onto the stage in Chapter 7.” The Press apologizes to the irrationals for the premature cue.
- Emendation (Theorem 16.4). First printings of the Einstein variation treated the denominator as fixed; since the variation is supported in $D\subseteq\Omega$, both integrals vary identically, and the correct statement carries the factor $(1-|T_{EH}|)$. The conclusion — stationarity ⟺ the vacuum field equations — stands, now honestly earned.
- Emendation (Theorem 16.2). The identification of slice totals with ADM mass is now stated through the constraint equations, with the non-localizability of gravitational energy confessed in open court.
- Emendation (Theorem 17.4). The boundary term of Gauss–Bonnet, once a placeholder, is now the geodesic curvature it always secretly was.
- Emendation (Chapter 17). The Tess functor is now presented with its morphism conditions explicit and its general program labeled as such.
- Throughout. The symbol $|T|$ denotes value and bold $\mathbf v$ denotes velocity; first printings allowed one letter to work two shifts. The union objected; the Press complied.
Index Selectus
approach — licensed, Ch. 8; unlicensed before ·
airfoil — 13.5; meshed, w18; companion, py18 ·
banker — 9.2; limit of all, 9.3 ·
cascade — 8.4; self-similar, ibid. ·
chambers — 7.5; enumerated by Pascal, 7.9 ·
denominator — see opus ·
equi-distribution — 13.1; mesher, w17 ·
freshman's dream — 7.5; remains a dream ·
gauge — 9.1; of $e$, 9.5; of any base, 9.7 ·
Hippasus — 7.10; drowned, allegedly, see Errata ·
mediant — see pooling ·
mirror — continuous; passim ·
opus — 2.1; juxtaposed, 3.5; multiplied, 5.1 ·
pooling — 3.5; no identity; Simpson's revenge, 3.6 ·
python companions — pyNN beneath every widget; Colab badges attached ·
reciprocal — swap, 6.1; involution, ibid. ·
tesseract — 7.6; vanishing, 7.7; animated, w10 ·
vermiculation — 2.3; without end, 8.1; machine, w02 ·
wrinkle — 8.6; ironed, ibid.
Further Reading
- T. Tao, An Introduction to Measure Theory — the grand unification, freely available.
- T. Apostol, Mathematical Analysis — Riemann–Stieltjes and the non-uniform ruler.
- M. Grabisch, Set Functions, Games and Capacities in Decision Making — the non-additive frontier.
- Any honorable probability text — the normalized world, where tesseractions work incognito.
- C. H. Hinton, A New Era of Thought (1888) — for the fourth rung, and the nerve to name it.
❦
FINIS LIBRI — but the tiles, being infinite, continue without us.