13 Nested Temporal Domains

Status: canonical synthesis note for multiscale coupling.

This note introduces Nested Temporal Domains as a causality-safe architecture for relating fast, meso, and slow processes inside Sandy Chaos. It does not replace the project's causal boundary, transport layer, observer-coupling layer, or continuity layer. It sits across them and proposes a clean rule for how temporally distinct domains may exchange usable information without collapsing into hand-waving.

1) Why this note exists

Sandy Chaos already had several pieces that implied multiscale structure:

timing asymmetry over proper-time offset,
read-write observer coupling,
fast / meso / slow control loops,
hyperstitional or narrative boundary variables,
continuity work that runs at different cadences.

What had been missing was a compact rule for how those layers should relate.

Without that rule, multi-timescale language gets loose. Every layer starts sounding like it can talk directly to every other layer, and the framework becomes harder to falsify.

This note proposes a stricter alternative:

Nested Temporal Domains are temporally banded domains that exchange only constrained, neighbor-layer representations under explicit latency, distortion, and reconstruction limits.

That keeps the project's multiscale language useful without granting magical cross-layer access.

2) Plain-language definition

A Nested Temporal Domain is a domain indexed by:

a role polarity (for example observer/observed, chaser/chased, parent/child), and
a temporal band (for example fast, meso, slow).

Each domain may communicate in two ways:

across polarity to its opposite-side counterpart at the same temporal band,
across tempo to an adjacent same-role domain at a neighboring temporal band.

That creates a grid-like architecture rather than a flat stack.

Example schematic:

slow observer   <---->   slow observed
      ^                          ^
      |                          |
      v                          v
meso observer   <---->   meso observed
      ^                          ^
      |                          |
      v                          v
fast observer   <---->   fast observed

The key restriction is that these links are neighbor-first.

3) Core primitives

3.1 Domain index

Write a domain as:

$$ D_{r,k} $$

where:

$r$ is the role polarity index,
$k$ is the temporal-band index.

A minimal local chart may be written as:

$$ D_{r,k} = (x_{r,k}, y_{r,k}, \pi_{r,k}, \delta_{r,k}) $$

where:

$x_{r,k}$ = local state,
$y_{r,k}$ = locally available observables,
$\pi_{r,k}$ = policy / interpretation / coupling state,
$\delta_{r,k}$ = latency budget or temporal contact quality.

3.2 Temporal band

The current project already uses a natural triplet:

fast — rapid local selection / correction,
meso — routing / alignment / summary,
slow — continuity / goals / policy burden.

More bands are possible, but the architecture should stay sparse unless measurement justifies finer resolution.

3.3 Adjacency

Adjacency is load-bearing.

By default:

a domain may couple to its opposite-role counterpart at the same temporal band,
a domain may couple to the same role at an adjacent temporal band,
direct long-jump or all-to-all coupling is not assumed.

This rule prevents unconstrained omniscience.

4) Allowed coupling types

Polarity coupling

Across-role, same-band transfer:

$$ E_{pol}: D_{r,k} \rightarrow D_{\bar{r},k} $$

Interpretation:

observer ↔ observed,
chaser ↔ chased,
parent ↔ child.

Temporal coupling

Same-role, adjacent-band transfer:

$$ E_{tmp}: D_{r,k} \rightarrow D_{r,k\pm1} $$

Interpretation:

fast observer ↔ meso observer,
meso observer ↔ slow observer,
fast task state ↔ meso summary ↔ slow continuity state.

Diagonal coupling

Direct diagonal coupling should be disallowed by default.

If a slow observer affects a fast observed domain, that interaction should usually be represented as a composition of admissible neighbor links rather than treated as magical cross-scale access.

5) Neighbor-layer codec

The central mechanism is not raw messaging. It is a neighbor-layer codec.

Each admissible transfer should be described using four operations:

Embed — write a constrained representation of local state into a neighbor layer.
Extract — recover a usable representation from the neighbor-layer signal.
Translate — convert that representation into local variables or control terms.
Reconstruct — form a bounded local model of the neighboring domain.

A minimal transfer object might look like:

TransferBundle {
  payload,
  source_domain,
  target_domain,
  latency,
  distortion,
  confidence,
  provenance,
  validity_window
}

Hard rule: no raw cross-domain state access

Domains do not get unrestricted access to one another's full state. They exchange:

compressed summaries,
bounded control signals,
gradient-like hints,
partial observations,
or policy-relevant aggregates.

This aligns with bounded-now access, partial observability, and information-bottleneck style coarse-graining.

6) Relationship to the rest of Sandy Chaos

01 Foundations

Nested Temporal Domains inherit the non-negotiable causal boundary:

no retrocausal channel,
no global-now oracle,
no future state determining present state.

7) What this buys us

Defensible now

Sandy Chaos already uses multi-timescale framing. Making the layer relations explicit improves conceptual hygiene.
Neighbor-first coupling is a better default than all-to-all access.
Explicit latency, distortion, and reconstruction burden make explanations more falsifiable.

Plausible but unproven

Modeling these relations as neighbor-layer encodings will improve explanation quality and eventually support cleaner experiments.
The same grammar may help unify protocol, cognition, continuity, and interface notes without forcing them into one ontology.

Speculative

Nested Temporal Domains may become a deeper unifying architecture across physics, cognition, narrative, and continuity.
That stronger reading should not do mechanism-level work unless benchmarked.

8) Failure conditions

This note fails if:

it becomes a fancy way to reintroduce omniscient cross-scale access,
the transfer objects remain too vague to model or benchmark,
the language grows more powerful while the admissible couplings stay untested,
or the architecture does not improve explanation quality compared with a simpler three-timescale story.

9) Summary

Nested Temporal Domains gives Sandy Chaos a stricter multiscale rule:

keep the causal boundary intact,
let neighboring layers exchange bounded representations,
make latency and loss explicit,
and refuse magical long-jump access by default.

That is a better architecture than saying “fast, meso, and slow exist” and stopping there.

13 Nested Temporal Domains