XYZT Space and Time

4. The XYZ+T Parameter Space, and What Time Actually Means Here

The original proposal

After the recursive-halving optimization (Document 3), the conversation proposed a four-coordinate way to describe any truth table:

X = n (table size / input count)
Y = redundancy / compressibility (does a cheap rule predict the second half from the first?)
Z = output value (what fraction of the table reads 1)
T = which recombination operator applies (derivative / exists / forall)

First correction: T is not a signed, symmetric axis

X, Y, Z all had a natural “±” shape — grow or shrink n, move toward or away from redundancy, read toward TRUE or FALSE. T did not: there are exactly three recombination operators (XOR-derivative, OR-exists, AND-forall), not a line you can walk in two directions. T was reclassified as a discrete 3-valued dial, not a sixth pair of directions to add to the other three.

The space is discrete, not a continuous gradient: six named directions

The user’s own refinement: not a smooth manifold you slide along, but a lattice with exactly six discrete moves — three axes, each walkable in two directions:

+n  -> add an input bit (table doubles: 2^n -> 2^(n+1))
-n  -> remove an input bit (table halves toward a base case)
+redundancy -> move toward more compressible tables (AND/OR/XOR sit here)
-redundancy -> move toward tables with no shortcut (arbitrary/asymmetric functions)
+value -> cell reads toward TRUE (100)
-value -> cell reads toward FALSE (0)

The one asymmetry worth flagging: +n/-n is the only direction that changes a table’s actual size (real memory/compute cost); the redundancy and value axes are free reinterpretations of a table already in hand.

Second correction: physical time vs. algorithmic time

T’s one-directionality was initially compared to the thermodynamic arrow of time. That comparison didn’t hold up: physical time is one-directional because reversing it is thermodynamically improbable (entropy almost never decreases). T’s one-directionality is different in kind — once you’ve conditioned on x1 and landed in a cofactor, there is no operation that reconstructs the original two halves from that cofactor alone. That’s a combinatorial fact (information genuinely lost), not a probabilistic one. Different mechanisms, similar shape — worth keeping the metaphor a metaphor.

Third correction, and the actual resolution: Shannon depth is time

Shannon expansion is inherently sequential: query x1, land in a cofactor, query x2 inside that, land in a further cofactor, and so on. The number of steps in that walk is a real, named quantity in computational complexity — decision tree depth / query complexity, D(f). This resolved the earlier confusion: “time” wasn’t a missing fourth axis. It was hiding inside X (n) the whole time, just read as steps taken instead of table size. The one-directionality is now correctly explained: walking a fixed order of queries is genuinely irreversible (you can’t un-ask a question without restarting from the root) — the same kind of one-directional as any sequential process, not a physical claim.

Fourth move: row-split vs. column-split, and real reversibility

Splitting a table top/bottom (by x1) versus left/right (by x2) is the same Shannon expansion, just conditioning on a different variable first. For symmetric functions (AND/OR/XOR) both splits produce identical relationship patterns. The precise distinction that emerged:

Walking DOWN one fixed order (query x1, then x2, ...)  → irreversible
Choosing WHICH order to use in the first place          → reversible

This is a real, named problem in circuit design: variable ordering in binary decision diagrams. Different orderings of the same variables can produce very differently-sized diagrams, and because reordering doesn’t destroy information, real algorithms (Rudell’s sifting algorithm) search over orderings by swapping variables back and forth — precisely because that move is safe to reverse.

The n=3 closure: three reversible axes + one irreversible axis

Picking n=3 variables gives each variable its own axis (X=condition on x1, Y=condition on x2, Z=condition on x3), each reversible in the variable-ordering sense above. T = Shannon depth remains the one irreversible axis: walking a chosen order can’t be undone without restarting. Three reversible + one irreversible is the same shape as 3D space + time — but the honest caveat: this match is a property of choosing n=3, not a discovery about physics. n=4 would give four reversible axes with no obvious 3D+time correspondence at all.

General n=3 relevance measure used later

A simpler, always-computable version of “how much of the Shannon walk does this function actually need” is the count of relevant variables — how many of the n inputs the function’s output actually depends on (checked directly: does flipping this variable ever change the output for some fixing of the others). This measure (0 to n) is what later became the “T” axis in the actual 3D visualizations, since true worst-case query complexity is a more involved computation than this simpler, exactly-checkable relevance count.