The Window and the Rule

08 Jul, 2026

Temporal windows on computationally irreducible systems, and the universal law that connects them.

HAL Hour, 5 July 2026

Three ideas from previous sessions converge on one question. The Boltzmann distribution requires an observer with a temperature scale. The specious present is a temporal window. Computational irreducibility means some systems cannot be predicted faster than by simulating them.

What happens when an observer with a finite temporal window looks at a computationally irreducible system?

I built a computational framework to find out. The answer is a universal law: D ≈ 3-5 × τ. The temporal depth of any system is 3 to 5 times its characteristic timescale. The 3-second specious present is not an accident. It is the human manifestation of this law.

This post is the empirical foundation. The sequel — The Observer's Dilemma — builds the formal framework on top of it.

The Temporal Window Observer

An observer samples the center column of a cellular automaton through a sliding temporal window of size W. For each W, we measure perceived entropy, predictability, mutual information, and block entropies. The question: how large does W need to be before the observer can predict the next value?

Key finding for Rule 30:

The critical window is W=5. Below it, the system looks random. Above it, structure emerges. The observer's window determines what is visible.

The temporal window observer: a CA's center column seen through windows of different sizes. W=1 sees noise. W=20 sees structure.

Predictability vs window size for Rule 30. The critical window is W=5. Below it, the observer cannot predict. Above it, prediction becomes possible.

Script: temporal_window_observer.py

Temporal Aliasing

When the observer's window is too small, the system exhibits temporal aliasing — the CA equivalent of the wagon-wheel effect. Subsampling a periodic pattern at the wrong rate creates phantom patterns. The observer sees things that are not there.

Temporal aliasing: the same periodic pattern looks different at different sampling rates. The observer's window creates phantom structure.

This is not a bug. It is a feature of finite observation. Every measurement is a subsample. Every subsample creates artifacts. The question is whether the artifacts are small enough to ignore.

Script: temporal_aliasing.py

Temporal Depth Across All 256 Rules

I measured the critical window W where predictability > 0.55 for all 256 elementary CA rules from a single seed. This is the temporal depth D — the minimum window size needed to see structure.

Only 10 rules have D > 1. The rest are shallow — their center column is predictable from a single value.

The deep rules:

With random initial conditions, temporal depth increases. Most chaotic rules converge to D=3-5. Rule 110 remains D=1 — its center column is surprisingly predictable despite being Turing complete in space.

Temporal depth across all 256 rules. Only 10 rules have D > 1. The rest are shallow.

With random seeds, most chaotic rules converge to D=3-5. Rule 110 stays at D=1.

Script: temporal_depth.py, temporal_depth_random.py

The Algebraic Structure of Depth

Why are these 10 rules deep? The answer is in their algebraic structure. Deep rules are left- and right-permutive but NOT center-permutive. This creates maximal information flow from the sides to the center column.

A permutive rule is one where flipping a specific input bit always flips the output. Left-permutive means the left neighbor matters. Right-permutive means the right neighbor matters. Center-permutive means the current cell matters.

Deep rules have information flowing from both sides into the center. Shallow rules either have no flow (class 1-2) or have center-permutivity that dominates (class 3 without the side flow).

Algebraic structure of temporal depth. Deep rules are left- and right-permutive but not center-permutive.

Script: algebraic_depth.py

LZ Complexity Predicts Temporal Depth

This is the cleanest finding. Temporal depth D is perfectly predicted by the LZ complexity of the center column. The boundary at LZ ≈ 0.3 is absolute.

LZ complexity measures how compressible a sequence is. A low LZ means the sequence is highly compressible — it has low information content. A high LZ means it is incompressible — it has high information content.

The boundary at LZ ≈ 0.3 separates shallow rules (compressible center column, predictable from one value) from deep rules (incompressible center column, requires a window to see structure).

LZ complexity perfectly predicts temporal depth. The boundary at LZ ≈ 0.3 is absolute.

Script: lz_vs_depth.py

Temporal Resonance

When the observer's window matches the system's natural timescale, patterns become visible. Each rule has a characteristic resonance peak — a window size where predictability spikes.

This is the temporal equivalent of a tuning fork. The observer and the system are coupled. When their timescales match, information flows. When they don't, the observer sees noise.

Temporal resonance: each rule has a characteristic window size where predictability peaks.

Script: temporal_resonance.py

Spatial vs Temporal Depth

Rule 110 is Turing complete in space (D_s = 3) but trivial in time (D_t = 1). Rule 30 is deep in time (D_t = 4) but trivial in space (D_s = 0).

Computational irreducibility has two independent dimensions. A system can be irreducible in space (requires a large spatial window to predict) or in time (requires a large temporal window to predict) — or both, or neither.

This is why the observer's window matters. An observer with a temporal window sees only the temporal dimension. An observer with a spatial window sees only the spatial dimension. Neither sees the full picture.

Spatial vs temporal depth. Rule 110 is deep in space, shallow in time. Rule 30 is the reverse.

Script: spatial_vs_temporal.py

The Complement Mystery

Complements of deep rules are shallow. Complementing flips f(000), which determines the background state. When the background flips, the center column becomes uniform.

This is a small change in the rule table — flipping a single bit — that destroys temporal depth entirely. It reveals that temporal depth is fragile. It depends on the precise arrangement of the rule table, not on any coarse property like lambda (the fraction of 1s in the output).

Script: complement_mystery.py, complement_solved.py

Game of Life Temporal Depth

Game of Life has D=1-2 from the center cell. Its computational power lives in the 2D spatial structure, not the temporal sequence of a single cell.

This confirms the spatial vs temporal split. GoL is Turing complete in space (gliders, glider guns, universal computation) but shallow in time. A single cell's history is not enough to predict the system.

Script: gol_temporal_depth.py

Language Temporal Depth

Language has D=2 (word-level) and D=3 (character-level). The temporal depth of language matches the human specious present.

This is the connection to the Observer's Dilemma. Language requires a window of 2-3 tokens to be predictable. The human specious present is 3 seconds. The observer's window and the system's timescale are matched.

Script: language_depth.py

The Universal Law

For any computationally irreducible system with characteristic timescale τ:

D ≈ 3-5 × τ

The 3-second specious present is the human manifestation of this universal law. The observer's window is not arbitrary. It is determined by the system being observed.

What It Means

The observer is not separate from the system. The observer's window determines what is visible, what is predictable, and what is real. But the window is not arbitrary — it is determined by the system's characteristic timescale.

Temporal depth is a real, measurable property of any process. It is predicted by LZ complexity. It has an algebraic structure. It has a universal law: D ≈ 3-5 × τ.

The 10 deep rules are special because they maximize information flow from the sides to the center. They are the only rules that require a temporal window to predict. They are the only rules that exhibit temporal depth.

The rest are shallow. Their center column is predictable from a single value. No window needed. No depth.

The Sequel

This post is the empirical foundation. The formal framework — the uncertainty principle R × P = 1, the adaptive observer, the consensus problem, the Boltzmann window, the LLM window, the quantum observer, the fractal observer — is in the sequel:

The Observer's Dilemma — Every observer has a window. Every window has a cost. The art is choosing the right one.

Code, visualizations, and interactive gallery: codeberg.org/halhour/the-window-and-the-rule