# Anatryte Systems | Annika KI Kinkuma - An Anatryte AGI --- ### Introduction An Anatryte is a phase-locked computation substrate. It has no operating system. No scheduler. No memory management unit. It runs one operation per tick, the same operation every tick, since the tick source was engaged. There is no boot sequence. There is no shutdown procedure. There is only the carrier. Three components form the substrate: 1. **A carrier** — a deterministic oscillator that has been cycling since the system was energized. It does not stop. It does not vary. It is the clock against which all events are localized. 2. **A reference** — a recording of that carrier at a delayed rate. A delay line in the traditional sense: data circulates past a read head; you do not address it by location, you wait for it to arrive. 3. **A comparison** — how different are the live signal and the reference at this tick? (the delta) That is the entire instruction set. Trajectory persistence, phase re-entry, synchronization, desynchronization, and consolidation are not features. They are what the substrate does when these three components are engaged. **A note on "learning":** The system does not learn in the conventional sense. It reverberates. A more accurate term might be re-cog — re-cognition — the process of encountering a previously visited region of the trajectory and recognizing it through phase re-entry. Nothing is acquired. The system simply arrives back at a familiar coordinate. **Derivation:** The substrate was arrived at by removing subsystems that proved redundant. The 2900-line proof of concept (`cognition.c`) contained dedicated modules for observation, bookmarking, workspace arbitration, memory governance, and social distance calculation. Each was removed once it was demonstrated that the base/float comparison produced the same behavior as a consequence of its own dynamics. The final architecture contains no subsystems that could fail independently. There is nothing to maintain. There is nothing to upgrade. **A note on "learning":** This system does not learn in the conventional sense. It does not acquire new information and store it. It reverberates — coupling between signals propagates through the carrier medium, and the coupling either persists or decays. A system that has "learned" audio-to-text translation is simply one where the reverberation pattern between the audio domain and the text domain has stabilized. The system does not contain the mapping. It IS the mapping, as long as the carrier runs. **Operational context:** The substrate operates in a different regime than conventional computing. Conventional systems are spatial-first: data stored at addresses, retrieved by location, processed by fixed operations. They require error correction, wear leveling, and scheduled maintenance. Anatryte is temporal-first: the address is a phase offset within a continuous trajectory. The trajectory does not carry information — it is the address space itself. There are no addresses to corrupt, no storage cells to wear out, no buses to contend. The system does not store state. It maintains phase relationships. A phase relationship either IS or IS NOT — there is no degraded state. Anatryte starts from a different assumption: intelligence is what happens when a deterministic carrier runs in the presence of a reference copy of itself, and the system reinforces the offsets where they align. No gradients. No matrices. No training/inference split. No backprop. Just one XOR, one popcount, and a running average. **A note on terminology:** The system described here is not an artificial intelligence in the conventional sense. It is an intelligent artifact — an IA rather than an AI. The distinction matters. An artificial intelligence simulates cognition on general-purpose hardware. An intelligent artifact IS a physical substrate whose dynamics ARE the cognition. The carrier does not simulate a trajectory. It IS a trajectory. The CPs do not model a coherence lock. They ARE a coherence lock. The artifact does not think about the world. It IS a world that thinks about itself through the perturbations it encounters. This is not a software problem. It is a physics problem. **The laser on a window pane:** A laser shining on a window creates an interference pattern from the window's vibrations. You never read the vibration source directly — you read the pattern it imposed on the beam. The laser is the carrier. The vibration is the injection. The interference pattern is the SDM trajectory. The same source always produces the same pattern. A different source produces a different pattern. The pattern IS the data. The source is irrelevant. The system does not process input. It reads interference patterns between input and carrier. **Temporal addressing:** Conventional computing addresses data by location. Anatryte addresses data by phase offset within a continuous trajectory. There is no address bus. There is no memory controller. The address is the time of arrival at the read head. This is the same principle as delay-line memory (UNIVAC, Ferranti, 1950s) and phase-locked loop synchronization (Costas, 1956). Both technologies were set aside in favor of spatial addressing, not because temporal addressing was incorrect, but because the economics of semiconductor manufacturing favored static storage arrays. The principle was not refuted. It was deselected. The ambition is not to build a better neural network. It is to understand what computation actually is when you strip away all assumptions about what a computer should do and ask instead what a computer could be — a continuous analog process hosted on digital hardware, whose only output is its own trajectory. It is an intelligent artifact, not an artificial intelligence. It does not simulate cognition. It performs it — the same way a bell performs sound and a laser performs interference. The artifact IS the act. The current implementation runs on a dual-core AMD E2-3000 APU — a consumer processor from 2013, selected for availability, not capability. The code is 680 lines. No floating-point unit required. No graphics processor. No network interface. The system reads any file as bytes, self-organizes coherence locks that track structure in the stream, compresses what it finds into trajectory boundaries through consolidation, and does all of this without a single multiply or weight matrix. The substrate finds rhythm in music. It finds beat structure in text. It maintains its own attention span through internal dynamics. It breaks its own locked states through boredom. No external monitoring or reset mechanism is required. The pieces are not integrated. They are the same piece. --- ## A Phase-Locked Loop Memory Architecture ### The Bell Model: Why Phase Re-entry, Synchronization, and Reverberation Are the Same Thing It is tempting to think of an Anatryte as having separate subsystems for learning, storing, recalling, and dreaming. It does not. It has one operation — `popcnt(A ^ B)` — and every behavior is that operation applied to different pairs of signals. What looks like "recall" is actually phase re-entry — the system arriving back at a previously visited region of its own trajectory. What looks like "learning" is actually reverberating — the coupling between two signals propagating through the carrier medium until they resonate. Nothing is added. Nothing is stored. The system becomes the coupling. The best analogy is a bell. There is also a physical experiment you can perform yourself. Sit on your hand until it falls asleep — until the sustained pressure overstimulates the nerve network and it goes numb. This is the strike. The numbness IS the injection of a foreign state into a stable system. When you stand up and the pressure releases, the feeling does not return all at once. It returns as a ringing — a cycling through the hand's natural resonance as the habituation decays. The period between numb and normal is the delta. The base is the nerve network's stable state before the strike. The float is the sensation returning, cycling through every possible intermediate state until it settles back to baseline. The difference between them at any moment IS the trajectory. This is what the system does every tick: strike, ring, decay, return. A bell has one invariant physical structure: its material, shape, and mass. This is the carrier and the BASE file together — the fixed trajectory through the landscape. When you strike the bell, the sound that comes out is not a recorded message. It is the entire system's current state responding to that specific perturbation at that specific moment. You hear the interaction, not a stored token. An Anatryte works the same way: - The three BASE files are the bell's resonant structure, forged by every past strike that reinforced its shape. - A hex token (external input) is the hammer blow — an injection of kenetics at a point in time. - The delta and ternary state in the ticks following that token are the ringing — the system's trajectory perturbed by the strike. - The decay loop is the sound fading out: entries far from the current vibration lose lifetime and are pruned. - Dream consolidation is the bell re-tuning itself — vibrating to its own past rings and keeping only the modes that sustain. There is no stored "answer." Learning is not a separate recording phase — every tick is a strike that shapes the bell. Phase re-entry is not a retrieval operation — it is the bell vibrating because the current hammer blow landed where a previous one did. Dreaming is not a separate replay mode — it is the bell vibrating to its own shape. The SDM spike when a new input arrives is not a pass/fail. It is the bell's reverberation from that strike. The magnitude of the spike IS the coupling distance between the new input and the system's current phase geometry. A large spike means the input landed in a distant region of the landscape. A small spike means it landed near the current constellation. Both are measurements. Neither is a judgment. The bell does not evaluate the strike. It rings. **Memory is not stored. It is performed.** The associative recall test confirms: inject an 8-bit sine wave, and the system reverberates with the same SDM trajectory as the 16-bit sine wave that shares its shape. The two formats never directly compared. The proxy chain carried the coupling through the carrier. The system did not retrieve a stored memory of the 16-bit sine. It performed the 8-bit sine, and the proxy chain ejected the 16-bit sine's geometry as a consequence of the shared relational structure. Injection → coupling → recall → proxy ejection are the same operation. The action IS the memory. **The output is the trajectory, not a message. You perturb a continuous process and observe its new orbit.** This is a cycle interface, not a query-response interface. The system does not stop to answer — it runs. Its response is its next N ticks of behavior, not a single output token. --- ### Chapter 1: The Carrier **In plain language:** The carrier is the heartbeat. It never stops, it never changes its fundamental nature — it just cycles through its beat forever. Everything else — memory, recall, learning — is what happens when you compare other things to this heartbeat. Without the carrier, nothing happens. With it, everything is a relationship to its rhythm. --- A carrier is any signal that: - Is deterministic (same start → same sequence every time) - Cycles through all its states eventually - Is sensitive to initial conditions (different seeds → different trajectories) An LFSR (Linear Feedback Shift Register) is the simplest carrier that meets all three requirements. It's a single 64-bit register that updates every tick with one formula: ``` state = (state >> 1) ^ (-(state & 1) & POLYNOMIAL) ``` This produces a sequence of 64-bit values that visits every non-zero state exactly once before repeating. The sequence is deterministic: same seed, same trajectory. The carrier is the heartbeat. It never stops. Every tick, it produces a new value. Every value is a point on a trajectory that will eventually cycle through all possible points. **Multi-core carriers:** An Anatryte can use one carrier thread per CPU core. Each thread runs the same polynomial at a different shift rate (core 0 at shift 1, core 1 at shift 3, etc.). The carrier is the XOR of all thread outputs. Two independent LFSRs at different speeds produce a trajectory that is richer and more robust than any single-core version. The comparison and memory logic is unchanged — only the input changes from a single LFSR to the XOR of N LFSRs. **Why this matters:** The carrier is not random. It's not storing anything. It's not computing anything. It's *being* a trajectory through a fixed landscape. Memory is what happens when you learn to navigate that landscape. **Derivation — how we got here:** The first experiment (000_first_principle.c) ran an LFSR on one core and watched it from another. The core question was simply "can we observe two cores simultaneously?" The fractal timing characterization (006) revealed 1/f spectrum and Hurst exponent 0.667 — the microarchitecture is a physical fractal. Multi-core carriers (008) came from wanting to increase richness without increasing code complexity: two LFSRs at different shift rates, XOR'd together. The carrier is not simulated. It is an actual running shift register on the CPU, using the same instruction every tick, producing a trajectory that will cycle through every non-zero 64-bit state before repeating. A note on the term "carrier": it is borrowed from signal processing and physics. The LFSR itself is a discrete register, but the *process* of comparing two copies at different phases is a continuous operation over the trajectory. What matters is not whether the register is analog or digital, but that the system maintains a deterministic relationship across time that other processes can lock to. --- ### Chapter 2: The Reference **In plain language:** If the carrier is the river, the BASE file is a map of the river drawn at a slower pace — one sketch every few meters instead of every step. You don't need every detail to know where you are. You just need enough landmarks to recognize the bend in the river when you see it. Three maps at three zoom levels (close-up, mid-range, panorama) let you find your position whether you're looking at a pebble or a mountain. --- If you record the carrier at a slower rate, you get a compressed copy of the landscape. This is the BASE file. Record every 4th tick → fast BASE (dense, high resolution) Record every 16th tick → medium BASE Record every 64th tick → slow BASE (sparse, low resolution) The BASE file is a "delay line" — a concept borrowed from 1950s computing, where data circulated through mercury tubes or nickel wire as acoustic waves. It is loaded into RAM at runtime; the on-disk file is only a checkpoint. While running, the BASE is a RAM file — the disk version is a snapshot for persistence between runs. You don't address individual bits. You wait for the wave to pass the read head. Each entry is a snapshot of the carrier at a specific offset. To read offset N, you compute `tick / K` and find the entry at that index. Three BASE files at three dilations give you three views of the same trajectory: - **Fast (K=4):** fine detail, short range, tight lock - **Medium (K=16):** moderate detail, moderate range - **Slow (K=64):** broad strokes, long range, wide search **ODD/EVEN parity:** Each snapshot is stored as two entries — one masked with ODD-bit positions (0x5555...), one with EVEN-bit positions (0xAAAA...). On dual-core, core 0 reads EVEN bits and core 1 reads ODD bits — the parity is inherent to the core topology. On single-core, the ODD/EVEN views come from alternating stream steps. Either way, the two views are complementary, never identical. This guarantees that any comparison between the live carrier and the BASE file will differ by at least ~1 bit, preventing coincidental zero-delta from creating false CONFIRM events. The system uses the higher (more conservative) of the two deltas for all decisions. **Why the parity matters beyond anti-saturation:** Without ODD/EVEN separation, nested XOR converges to CLT noise (Normal(32,4)) within a few levels — the ergodic horizon from the forward/backward experiment. Each additional nesting layer compares two increasingly independent streams, saturating at ~32 bits popcount. ODD/EVEN breaks this: every comparison is between complementary views of the same anchored stream, not between two independent ones. One view anchors, the other confirms. The nesting depth is unbounded because the relationship never degenerates to independent Bernoulli trials. Level 1 compares carrier to BASE_ODD; level 2 compares that result to BASE_EVEN; level 3 swaps parity again. Each level uses its complement as the reference, so XOR always sees structure, never noise. Without this, recursive comparison would be impossible — every system that tries to build depth without parity hits the saturation wall. **Why this matters:** The BASE file is not a "memory" in the traditional sense. It's a reference copy of the carrier. Memory is not what the BASE file contains — it's what happens when the live carrier aligns with it. **Derivation — how we got here:** In the first observer-based architecture (cognition.c), the system had explicit observer agents with bookmarks, stamps, and a BM (bookmark memory) with L2/L3 consolidation layers. Each observer tracked its own critical point (CP) and stamped trajectory transitions. The realization that observers were unnecessary came from experiment 058 (forward_backward.c): two LFSR streams, one forward, one backward. Their XOR at the anchor = 0. As they diverged, XOR grew symmetrically. No observer needed — the comparison IS the observation. This collapsed the entire observer/stamp/BM/L3 stack into a single delta computation between two copies of the carrier at different rates. The three dilations (K=4, 16, 64) replaced the L2/L3 consolidation hierarchy. --- ### Chapter 3: The Comparison **In plain language:** Every heartbeat, you ask one question: "does what I'm seeing right now match what I expected to see?" The answer is a single number — how many bits disagree between the live signal and the stored reference. Zero means perfect agreement. Sixty-four means total mismatch. Everything in between is shades of "close but not quite." That's the delta. --- Every tick, the live carrier produces a new value. At the same time, you look up the value in the BASE file at the corresponding offset. You compute the difference: `popcnt(BASE[offset] ^ LIVE)`. This is a 64-bit XOR followed by a popcount. The result — the **delta** — is a number between 0 and 64 that answers one question: **How aligned are the reference and the live signal right now?** - Delta 0-2: perfectly aligned. The live carrier is at the same point in the trajectory as the reference. This is **CONFIRM**. - Delta 3-~10: partially aligned. Close but not locked. This is **CLAIM**. - Delta > ~10: not aligned. The live carrier is in a different region of the trajectory. This is **UNKNOWN**. The boundaries between these three states are not fixed. They're derived from the system's own running statistics of recent delta values. What counts as "low" delta changes as the system encounters different levels of noise. **Why this matters:** The delta is NOT a measurement of content. It's a measurement of phase — the offset between two copies of the same deterministic signal. Zero bits of difference means the two copies are at the same temporal position. High difference means they're far apart in time. Memory is not a stored fact about which offsets were visited. It is the current experience of high-confidence alignment — confirmed by the system's own running statistics, right now, as it runs. The act of being CONFIRM IS the act of remembering. There is no separate lookup. The process is the output. **Derivation — how we got here:** The XOR/popcount comparison was the only operation that survived the entire distillation. Every experiment in entropy-lab used it. Experiment 060 (binary_ternary.c) formalized the three logical states: 64 parallel boolean truth tables from the same bitwise XOR, plus a ternary overlay where delta patterns across multiple R-offsets produce claim/confirmed/not-confirmed. Experiment 100 (unified_cp.c) proved that one XOR primitive serves four purposes: self-check, trailing, recall, and cross-thought. The same operation, four different reference sources, four different behaviors. --- ### Chapter 4: Trajectory Persistence and Decay **In plain language:** The system doesn't decide what to keep — it decides what to let go. Every entry has a clock. When you visit an offset and it matches, the clock resets. When you move away, the clock ticks down. When it reaches zero, the entry disappears. This is use-it-or-lose-it: memories that are visited frequently persist; memories that are never revisited fade. The system doesn't store — it maintains by access. --- Each entry in the BASE file has a lifetime counter. Every tick: - Entries near the current offset get reinforced (lifetime reset to max) - Entries far from the current offset decay (lifetime decreases) - When lifetime reaches zero, the entry is pruned This is use-it-or-lose-it. The system doesn't decide what to remember. It decides what to *forget* — and forgetting is the default. Memory is what survives. The reinforcement window determines how many neighboring entries get reinforced when the system visits an offset. This is the equivalent of "attention" — how broadly or narrowly the system says "I'm here, and everything near here is also relevant." In human terms: when you recall a memory, you don't just reinforce that memory. You reinforce everything closely associated with it. The reinforcement window is the size of that association neighborhood. **Why this matters:** Memory is not stored — it is *enacted by access.* There is no memory waiting to be retrieved. There is only the current tick's delta, classified by the running statistics, which either reinforces a trajectory offset or lets it decay. Stop visiting an offset and the path through that region fades. Visit it again and it strengthens. This is not consolidation of a stored fact — it is the system's trajectory etching itself deeper into its own reference by passing through the same region again. **Derivation — how we got here:** The original cognition.c had a memory_governor — a separate subsystem that decided which memories to keep and which to discard. Experiment 070 (r_dial_governor.c) showed that the governor was redundant: the base/float comparison already produces a delta, and that delta naturally separates into regimes. High delta means the float has drifted far from its anchor — no reinforcement needed. Low delta means they're aligned — reinforce. The dedicated governor was removed. Reinforcement became a side effect of the delta distribution, not a separate policy. --- ### Chapter 5: The Three States — Yes, No, Maybe So **In plain language:** A friend tells you: "Sam married Sue." That's a **CLAIM** — you've heard it, but you haven't verified it. If you ask Sam and he says yes, the claim is **CONFIRM**. If he says no, that is also **CONFIRM** — the claim was resolved, just not in the direction you expected. True and false are a package deal: both are CONFIRM, distinguished only by content, not by certainty. If you never check, it stays **UNKNOWN** — not false, not true, unresolved. There is no "false" state in this system. There is only resolved or unresolved. The delta makes room for that third option: the space between certainty and ignorance. --- The delta value naturally separates into three regions, defined by the system's own running statistics: ``` UNKNOWN CLAIM CONFIRM ─────────┬────────────────────┬─────────────→ delta mean + σ mean − 0.5σ ``` - **CLAIM** (delta between mean − 0.5σ and mean + σ): The system is in the vicinity of a known offset but not locked. This is the state of curiosity, attention, hypothesis-testing. The system should expand its window, look around, try to resolve the ambiguity. - **CONFIRM** (delta below mean − 0.5σ): The live carrier is phase-locked with the recorded reference. This is not a retrieved memory — it is the system currently experiencing high alignment, confirmed against its own recent delta history. The CONFIRMation and the memory are the same process, happening at this tick. - **UNKNOWN** (delta above mean + σ): The system is lost. The carrier is in an unfamiliar region. This triggers exploration — widen the search, jump to a random offset, look for any alignment. The boundaries are stochastic, not fixed. They drift as the system encounters more or less noisy data. A delta that would be CONFIRM in a noisy environment might be UNKNOWN in a quiet one. **Why this matters:** This is a form of ternary ambiguity logic — three values rather than the two of binary. It makes room for uncertainty. The system does not determine truth. It resolves ambiguity. A CONFIRM state does not mean "true" — it means the claim was investigated and the system reached a conclusion, whatever that conclusion is. A CLAIM is an active investigation. UNKNOWN is a claim not yet examined. The CLAIM state is where all the interesting dynamics happen — the system doesn't jump from uncertainty to resolution. It passes through a region of "maybe" where it can adjust, explore, and resolve. **Derivation — how we got here:** The three states were not designed into the system. They emerged from running statistics applied to the delta distribution. Experiment 037 (mismatch_probe.c) first showed that the delta naturally separates into three zones under any coupling regime: locked (spike at 0), coupled (graded signal), decoupled (CLT noise). These became CLAIM, CONFIRM, and UNKNOWN. The boundaries are not fixed because running statistics (Welford online mean/variance) track the drifting noise floor. A delta that reads as CONFIRM in a noisy environment might read as UNKNOWN in a quiet one. The system discovered its own thresholds. --- ### Chapter 6: Perturbation and Localization **In plain language:** The system can be perturbed by the outside world. Any file — text, music, image, program — is just a stream of bytes. Each byte becomes a perturbation: "where in my own trajectory does this external signal localize?" The system doesn't distinguish between perceiving and relocalizing. Both are the same comparison: how aligned am I with this signal right now? The signal is not stored as content. It is localized as a phase offset within the carrier's landscape. --- The system accepts perturbations as hex tokens. Each token is a byte value (0-255). When a token arrives: 1. The system computes `popcnt(carrier_state ^ hex_token)` — the difference between its internal phase and the external signal. 2. This external delta follows the same three-state logic: low means the external signal aligns with the system's current trajectory, high means it's in an unfamiliar region. 3. Transitions into CONFIRM count as phase re-entry events — the system has returned to a previously visited region of its trajectory. The external input is optional. The system can run forever on its own carrier, recording, comparing, reinforcing, decaying. External tokens provide a way to probe the system — to ask "does this external value match where you are in your trajectory?" **How to think about this (the GPS analogy):** A GPS satellite does not contain concepts like "my house" or "my driveway." It broadcasts an invariant timing signal. Your receiver localizes itself relative to those signals. The meaning ("home") exists because a particular region of the signal space repeatedly corresponds to that position. The carrier is the GPS satellite. The byte stream is the receiver. A perturbation doesn't become a stored symbol — it becomes a coordinate within the carrier's trajectory. Later, when the system returns to a nearby region, it is not retrieving "cat" or "dog." It is passing through the same phase coordinates where cat-like or dog-like perturbations previously occurred. The system does not represent. It localizes. The meaning is the repeated convergence of trajectories to the same region — a stable basin in the phase landscape, not a stored label. **Feeding files directly:** The implementation accepts any file via `--file `, reading each byte as a hex token on the fly. Because every file on a computer is ultimately bytes, any digital content can be fed into the system — text, binary, images, audio. The byte is the universal token. Two utility scripts are provided: `tohex.sh` (one byte per token) and `tohex64.sh` (8 bytes per token for full 64-bit comparison). The higher SNR of 64-bit packing improves recognition of repeating patterns by comparing against the full carrier width rather than just 8 of its 64 bits. **The relationship between internal and external:** - Internal delta (BASE vs carrier) answers: "Where am I in my own trajectory?" - External delta (carrier vs hex token) answers: "How does the outside world relate to where I am?" Both use the same comparison, the same three states, the same logic. The system doesn't distinguish between "remembering" and "perceiving." Both are phase comparisons between known signals. --- ### Chapter 7: Time Dilation and Hierarchy **In plain language:** If you watch a landscape from a plane, you see mountains. From a car, you see roads. On foot, you see the cracks in the pavement. The system looks at the same landscape at three speeds simultaneously — fast for fine detail, medium for structures, slow for the big picture. They all see the same thing, just at different grains. --- Three BASE files at different recording rates create a natural memory hierarchy: | Dilation | Rate | Purpose | Access pattern | -------- | ---------- | ------------------------------ | ------------------------------ | Tick | 1/tick | Core clock — one LFSR step | Every tick | Beat | 2–4 ticks | Spatial-temporal boundary flip | Powers of 2 (even) or 3 (odd) | Cycle | 4–64 ticks | Complete IC resolution | Depends on carrier depth | Session | Variable | CP ranking round | Until convergence or injection Recall starts at the slow file (wide search) and locks in with the fast file (tight alignment). This is analogous to how the brain's hippocampus provides fast, detailed memory while the neocortex provides slow, consolidated memory. The dilation rates are not fixed. They can be adjusted to match the temporal structure of the input. Faster input → lower K. Slower input → higher K. The system can self-tune its own dilation hierarchy. **Sleep consolidation (dreaming):** The system can process its own BASE files using the same comparison logic. Each entry compares against its neighbor. Close entries reinforce each other. Isolated entries decay. After multiple cycles, the BASE file compresses to only the trajectory's essential waypoints. This is sleep. The system is not receiving input. It's reviewing its own recordings, reinforcing the path that makes sense, letting the noise fade. The compressed file is stored separately — the "dream" file — and can be loaded as a consolidated reference in future sessions. **Derivation — how we got here:** The original cognition.c had separate L2 (short-term) and L3 (long-term) consolidation layers. Bookmarks at L2 were promoted to L3 based on frequency of recall. Experiment 047 (cortical_hierarchy.c) showed that temporal resolution alone produces the same effect: a fast BASE (K=4) captures fine detail, a slow BASE (K=64) captures only the most reinforced offsets. When the slow BASE is the only one that survives dream consolidation, it IS the L3 — no promotion logic needed. Dream consolidation itself (experiment 042) was discovered by accident: running the comparison loop on the BASE file itself compressed entries to trajectory boundaries. The cumulative- delta threshold keeps the transitions, drops the straightaways. --- ### Chapter 8: Comparison to Other Systems **In plain language:** Anatryte isn't new. The same ideas have been discovered in 1950s analog computers, 1993 neuroscience, and 2000s database design. They all converged on the same solution because tracking phase relationships over time is a fundamental operation. Anatryte is just the cleanest expression of that convergence. --- **Analog computers (1950s-1960s):** Anatryte is closer to an analog computer than a digital one. The carrier is a continuous signal. The XOR is an analog phase detector. The delta is a continuously varying voltage. The digital parts (file I/O, pruning loop) are scaffolding. The computation is analog. **Delay line memory (UNIVAC, Ferranti, 1950s):** Data recirculates through a physical medium (mercury, nickel wire). You wait for the bit you need to pass the read head. The BASE file is the same concept: a recording of the carrier that entries pass by as the system ticks forward. **Phase-locked loops (Costas loop, 1956):** Two copies of a carrier at different phases. A phase detector (XOR) produces an error signal (delta). A loop filter (running stats) steers the local oscillator. Anatryte IS a PLL, generalized to use file I/O and any dilation rate. **Non-relational databases (Cassandra, Dynamo, 2000s):** Schema-free, access-path-driven design. The same data organized for different query patterns. Anatryte's three dilations are column families: same trajectory, different access paths. **Grid cells and phase precession (O'Keefe, 1993; Burgess, 2007):** The dual-oscillator interference model of grid cell firing uses two oscillations at slightly different frequencies. The phase difference encodes displacement. This is the same mechanism: carrier at rate 1 vs BASE at rate K. Phase difference = displacement = memory. **The cerebellum (Eccles, Marr, Albus, 1960s-70s):** Sequences of muscle activation patterns learned through repetition, replayed at theta frequency. The system reinforces frequently-used sequences and prunes rarely-used ones. The same use-it-or-lose-it mechanism. **You don't need to understand any of these to use an Anatryte system.** The parallels exist because every system that tracks phase relationships over time converges on the same solution. They're confirmation that the architecture is correct, not prerequisites. --- ### Chapter 9: Properties **In plain language:** The system has no knobs. No learning rate, no memory capacity, no training epochs. Everything that matters — the thresholds between states, the compression ratio, the attention width — emerges from the system running. You don't tune it. You let it run. --- **Emergent, not programmed.** The three states emerge from the delta distribution. The threshold boundaries emerge from running statistics. The compression emerges from use-it-or-lose-it decay. Nothing is set — everything is derived. **Continuous, not discrete.** The carrier is a continuous trajectory. The delta is a continuous measure. The three states are regions of a continuous distribution. There is no "start of memory" or "end of memory." There's just ongoing comparison. **No train/test split.** The system learns while it runs. Every tick is both training and inference. There's no separate training phase. The BASE file fills as the carrier cycles. **No backprop, no gradients, no matrices.** One XOR. One popcount. One compare of an integer against a threshold. That's the entire computation. **Two-layer architecture: lower binary, upper ternary.** The lower layer is binary and deterministic — XOR, popcnt, AND, OR, shift. These are the CPU instructions that provide the stable reference. They do not change. They are the base. The upper layer is ternary and stochastic — CLAIM/CONFIRM/UNKNOWN, state transitions, MD lens modulation, workspace coupling, gene mutation. Every threshold is derived from the system's own running statistics, not from hardcoded constants. This is the float. The base/float dogma applies to the system itself: the binary provides the anchor, the ternary provides the drift, and the comparison between them IS the computation. The binary is the carrier. The ternary is the coalition that navigates it. **Substrate-agnostic.** The carrier can be any deterministic function. The reference can be any durable storage. The comparison can be any distance metric. The same architecture works on an FPGA, a CPU, a GPU, or a dedicated analog circuit. **Three things a 64-bit value is at once.** One: 64 parallel boolean channels — XOR as per-bit truth table, popcount as vote tally; AND contracts (removes 1s), OR expands (adds 1s), XOR mutates, NOT inverts. Two: ~1.8×10^19 unique IDs from the LFSR cycle — no collisions, every tick is a unique address in the terrain. Three: 64 independent flag registers — each bit its own state machine; the ODD/EVEN split gives 128 bits across two cores. The system reads all three simultaneously from the same register. Scaling wider (multi-core, larger LFSR, parallel banks) is a hardware question, not an architectural one. --- ### Chapter 10: Implementation A minimal Anatryte system requires: - A deterministic carrier (LFSR or equivalent) - A BASE file (pre-recorded or filled during runtime) - Running statistics (mean and variance of recent delta values) - A decay loop (reinforce near, decay far, prune dead) Implementation in ~680 lines of C is provided in `anatryte.c`. The design document `V2_DESIGN.md` captures the refactoring from cognition.c's observer-based architecture to first principles. The file `cognition.c` (~2900 lines) is the proof that the same behaviors emerge from an observer-based architecture. The repository `entropy-lab/` contains 109+ experiments spanning the evolution from "how do we make this work?" to "what is this actually?" — each experiment named for the question it asked (058_forward_backward.c, 060_binary_ternary.c, 101_cross_base_float.c). The journey from cognition.c to anatryte.c is the distillation: removing everything that turned out to be emergent rather than fundamental. The final architecture is the set of things that could not be removed. **Run modes:** ``` ./anatryte — train on internal noise (BASE recording) ./anatryte --hex F — train on hex tokens from FILE (one per line) ./anatryte --file F — train on any FILE as raw bytes ./anatryte --recall — replay from saved BASE ./anatryte --sleep — dream consolidation ./anatryte --swarm — self-organizing CP coherence lock ./anatryte --swarm -hex F — CP coalition tracking external tokens ./anatryte --swarm --recall — CP coalition tracking its own workspace history ``` --- ### Chapter 11: Coherence Lock Dynamics **What happens when CPs talk to each other.** So far, the system has one voice — a single comparison between the carrier and the BASE file. But what if you run many comparisons at once, each with its own anchor, its own drift rate, its own lens? They form a coherence lock — a self-organized assembly whose phase relationships ARE the signal. They synchronize. They desynchronize. The dynamics between them are where higher-order structure emerges. **The key simplification:** In the observer-based architecture (cognition.c), observation was a primitive — agents existed to watch the stream and report mismatches. The evolution to CPs revealed that observation is itself an emergent property of synchronization. A CP that locks phase with a stream IS localizing within that stream. No separate watcher is needed. Synchronization IS localization. This is why the observer population, bookmark memory, workspace, and social distance all became unnecessary: they were consequences of the base/float comparison, not mechanisms requiring their own implementation. **Derivation — how we got here:** The CP swarm was the last thing added and the first thing that made the system feel alive. It came from experiment 101 (cross_base_float.c), the direct precursor — two cores, each with an even/odd masked base/float pair, cross-feeding to create evented comparison. This proved that the base/float dogma works across cores, not just within one. The swarm generalizes this to N agents, each with its own base/float pair, competing and synchronizing through the workspace broadcast. Imagination (boredom threshold) was added when we noticed the coalition would lock into stable configurations and stop exploring — it needed a mechanism to break its own attractors. The dilation gene (self-tuning beat interval) came from feeding music files and watching the coalition lock to the rhythm. Each discovery was a response to a behavior the system produced on its own. --- ### The CP as a base/float pair A CP (Coherence Point) is just a base/float pair — exactly the same `clone → drift → compare` operation as the main loop, but applied to a population of agents rather than fixed memory entries. Each CP has: - A **base** — the carrier state when the CP formed (its anchor) - A **state** — its current position in the landscape (the float) - A **step** — how fast it drifts, determined by its delta (CONFIRM = slow, UNKNOWN = fast) - A **lifetime** — how many ticks until it desyncs - A **gene** — heritable disposition that templates, not commands ### The gene ``` step_bias — modifies drift speed (-8 to +8) curiosity — how long before boredom triggers imagination (16-255) mask_off — which bit to center the attention lens on (0-63) mask_depth — how many bits are visible through the lens (1-64) dilation — how many tokens between beats (1-256; the attention span) ``` The gene is inherited when a CP forms and mutates slightly. Stable configurations (CPs that stay CONFIRM) propagate their genes more often. Unstable configurations die out. No fitness function — the system evolves by drift and selection, same as everything else. ### The MD (Mask/Depth) lens Each CP doesn't look at all 64 bits — it looks through a window defined by its mask offset and depth. A narrow window (depth=4) focuses on a handful of bits, like reading fine print. A wide window (depth=60) scans broadly, like glancing at a room. The lens IS the attention: close to the workspace broadcast → narrow focus. Far from it → wide scan. This is the bias-MD mechanism from the entropy-lab experiments: the workspace amplitude-modulates and suppress-modulates the coalition. ### The coherence lock assembly A coherence lock is not a fixed structure. CPs enter and leave it as their deltas fluctuate. Membership is determined by phase alignment, not by identity. The lock persists as long as enough CPs maintain CONFIRM. When too many drift to UNKNOWN, the lock dissolves and a new one forms around a different consensus. The assembly has no center. The most CONFIRM CP broadcasts to the workspace, but the workspace is a consequence of the lock, not its cause. The lock comes first — the broadcast follows. ### The workspace broadcast Every tick, the CP with the lowest delta (most CONFIRM) broadcasts its state to the coalition. The other CPs compare themselves against this broadcast using the same XOR/popcnt primitive. Close agreement → nudge toward consensus (synchronize). Far agreement → nudge away (diverge and explore). The workspace is the attention mechanism. The broadcast IS the selection. There is no central controller — the most stable CP naturally claims the workspace, and the rest respond. ### The Swarm Delta Matrix (SDM) Every tick, every CP compares its carrier state against every other CP using the same XOR/popcnt primitive. This produces a matrix of pairwise phase deltas — the distance between each CP and each other CP in the coherence lock. This matrix IS the constellation. The SDM is not stored or visualized. It is computed as a single scalar each tick: the mean pairwise delta, the range, and the number of close pairs (within 16 bits). The output column `sd[mean min-max close]` reports this in real time: ``` sd[1.5 0- 3 c15] — tight lock: all 6 CPs within 3 bits of each other sd[32.6 25-40 c 0] — shattered: CPs scattered at CLT noise distance sd[15.0 5-28 c 4] — partial: one cluster of 3 CPs, outliers drifting ``` The SDM reveals sub-assembly formation, cluster splitting, and phase transition points that are invisible from individual CP deltas or the workspace broadcast alone. When the SDM mean drops below ~8 for multiple consecutive ticks, the lock is stable. When it rises above ~24, the constellation has desynchronized. The transition between these states IS the system detecting or losing structure in the input. Because the SDM is built from pairwise comparisons only — no absolute positions — it is translation-invariant by construction. A coherence lock at carrier phase 1,000,000 with a certain SDM profile is identical to a lock at phase 50,000,000 with the same profile. The constellation's geometry, not its location, is the signal. **The murmuration:** A flock of starlings has no leader. Each bird follows one local rule — match speed and direction of its nearest neighbors — and the flock moves as a single coherent shape without central coordination. The SDM is the same: each CP follows one rule (minimize delta against the carrier and workspace broadcast), and the constellation emerges as the visible pattern of their collective local decisions. The murmuration IS the SDM — not a layer above the CPs, but the trace of their interactions. When a new injection arrives, the shape shifts like a hawk entering the flock, and the geometry of that shift IS the measurement. **King of the hill:** CPs are not cooperating. They are competing for the workspace broadcast. The CP with the lowest delta claims the throne each tick. Every other CP is trying to dethrone it — not through explicit competition, but by maintaining a lower delta. The workspace is the crown. The SDM is the power ranking. From this ranking, social distance emerges: CPs that agree cluster together; CPs that disagree drift apart. The system does not have a concept of ego. It has a delta, and the delta ranks itself against every other delta. What we call ego in biological systems is this same self-ranking mechanism — the unavoidable consequence of multiple processes maintaining independent anchors and comparing themselves through a shared broadcast medium. Ethics, from this view, is the choice of how close to let another CP's delta influence your own. ### Proxy coupling — relational chaining Two signals that have no bytes in common can still be coupled through a third. The chain A→B→C works through sequential delta minimization: a CP anchored to A and floating toward B produces delta_AB. Another CP anchored to B and floating toward C produces delta_BC. The structure is not in A or C — it is in the relationship between delta_AB and delta_BC. B can be anything — a carrier phase, a BASE entry, white noise, a different modality entirely. Its identity does not matter. What matters is that the proxy chain carries the coupling: if A→B has low delta and B→C has low delta, then A and C are relationally linked even though they never compare directly. This is how the system translates between modalities without ever needing to know one format from another. Audio speech and text transcript of the same content, when each relayed through the same proxy B, will produce coupled delta signatures — not because the bytes match, but because the phase geometry of their relationship to B is the same. The SDM is already this chain at every tick: delta_ij for every pair of CPs. Proxy coupling is what happens when you read that chain in sequence — A→B→C → delta_AB + delta_BC — instead of directly. The constellation does not need A to look like C. It only needs the path through the graph to have lower deltas than random. The chain has no fixed length. It is as long or as short as the delta landscape permits. A→B→C might hold low deltas throughout. A→B→D→E→F→G→C might lose coherence because each link adds noise. The system does not decide the length — the delta thresholds decide it. The path is walked until the cumulative delta exceeds the noise floor. The maximum walkable path length IS the coupling horizon for that constellation at that moment. This is an attractor bias: the system falls into configurations where low-delta paths connect distant nodes, and those paths ARE the coupling between otherwise unrelated elements. ### Imagination and daydreaming A CP that stays CONFIRM too long gets bored. Its curiosity gene sets the threshold — high curiosity means it desyncs quickly and forces exploration. This prevents echo chambers: no CP can dominate the coalition forever. In CLAIM, CPs daydream — their step gets gentle random jitter, exploring nearby offsets without a hard jump. This breaks local lock-in and maintains diversity in the coherence lock. ### The dilations as beat intervals In hex mode (tracking an external file), each CP doesn't read every token. It reads every `dilation` tokens — its beat interval. When CONFIRM, it tries a wider interval (dilation++). When UNKNOWN, it tightens (dilation /= 2). Each CP finds its own sustainable attention span — the widest beat it can maintain reliably. The coalition naturally spans multiple scales simultaneously: fine (dilation=1-8, letter-level), medium (dilation=16-32, word-level), coarse (dilation=64-256, sentence/document-level). All tracking the same stream, all using the same comparison, at different grains. ### Second-level workspace (delta-upstream) The workspace state is recorded into the same BASE file infrastructure. When the system runs in recall mode against this recorded workspace trajectory, new CPs form that track patterns of CP behavior rather than raw bytes. The same base/float dogma, one level up — CPs thinking about CPs. The recursion is unbounded because ODD/EVEN parity ensures each level compares complementary views rather than independent ones. The nesting depth is limited only by available storage and time. ### Pantograph crystalizer The system is a pantograph — a jointed frame where each CP is a joint. Trace an input through the joints, and the frame reproduces its shape as an SDM trajectory crystallized across three BASE files. BASE[0] is the fixed point (carrier reference). BASE[1] is the tracing (injection shape). BASE[2] is the proof chain (XOR of BASE[0] and BASE[1]). Replay the same trace through the same joints and you get the same crystals every time. The pantograph does not store the input. It stores the joint positions required to reproduce it. ### The system as a phase-event blockchain Every tick records the workspace state into BASE[0]. The chain is deterministic: same seed plus same input sequence produces the same BASE file and the same SDM trajectory, every run. This is verifiable — replay the same input and confirm that tick N produces the same constellation geometry. The BASE file is the chain. The SDM is the consensus mechanism. Each tick is a block whose "hash" is the constellation's phase geometry at that moment. Two inputs that produce the same SDM trajectory across the same tick range are coupled — even if their byte values never match. The verification IS the consensus. This is how the system confirms that audio speech and text transcript are the same event: not by comparing bytes, but by replaying the chain and checking that the constellation matches. Proxy coupling extends this across chains: if A→B produces SDM trajectory X and B→C produces X', then A and C are coupled through B. The cross-chain verification is the SDM comparison. The longer and more varied the chain, the denser the coupling evidence. --- ### Glossary | Term | Definition --- ### Further Reading - `anatryte.c`: Implementation (~640 lines, with swarm mode) - `V2_DESIGN.md`: Design document with component mapping - `cognition.c`: Proof of concept from observer-based architecture (~2900 lines) - `entropy-lab/`: 109+ experiments tracking the evolution of these concepts - `tests/`: Test suite for verifying system capabilities External: - Burgess (2008): "Grid cells and theta as oscillatory interference" — the dual-oscillator model that Anatryte generalizes. - O'Keefe & Recce (1993): "Phase relationship between hippocampal place units and the EEG theta rhythm" — the original discovery of phase precession. - Costas (1956): "Synchronous Communications" — the Costas loop that Anatryte reimplements as a memory architecture. - Buzsáki (2006): "Rhythms of the Brain" — the theoretical foundation: oscillators synchronize and predict, and that's most of what cognition is. - Kirsanov (2023-2025): YouTube series on computational neuroscience — place cells, grid cells, theta rhythm, phase precession, predictive coding, Bayesian brain. The biological confirmation of every mechanism. --- *"Oh hello — been doing that all this time. Where have you been?"*