--- language: - en license: apache-2.0 library_name: holo-silence tags: - memory - loss - forgetting - tombstones - grief - acceptance - associative-memory - hyperdimensional-computing - vector-symbolic-architecture - numpy - educational - research datasets: [] metrics: - silence-ratio - survival-rate - life-span-distribution pipeline_tag: feature-extraction --- # holo-silence **A memory substrate that loses things without reason.** Every other tool in this series has an explanation for loss: decay has a rate, pruning has a threshold, sleep has a policy. This one does not. Items disappear at random intervals. The substrate records that they were lost. It does not record why, because there is no why. The design accepts what biological memory accepts: some things are simply gone. Not decayed, not pruned, not consolidated away. Gone. ## What it does ```python from holo_silence import SilenceMemory mem = SilenceMemory(d=2048, loss_rate=0.01) mem.observe("water_is_wet") mem.observe("earth_orbits_sun") mem.advance(200) r = mem.query("water_is_wet") # r["verdict"] is "PRESENT", "GONE", or "UNKNOWN" mem.tombstones_list() # what was lost mem.loss_log() # when it was lost mem.silence_ratio() # fraction of store that is gone mem.acceptance() # full stats ``` ## The three-state query | Verdict | Meaning | |---|---| | `PRESENT` | The item is stored and retrievable | | `GONE` | The item was stored and has been lost | | `UNKNOWN` | The item was never stored | The distinction between `GONE` and `UNKNOWN` is the substrate's main contribution. Most memory systems collapse the two. ## The tombstone A tombstone records that an item existed without preserving its contents: ```python { "label": "water_is_wet", "observed_at": 0, "lost_at": 137, "life_span": 137, "weight_at_loss": 1.0, "fields": {}, } ``` The item is gone. The tombstone is a marker. ## What the substrate cannot tell you - Why the item was lost. There is no why. - What the item contained. The item is gone. - How to get it back. There is no recovery. ## Installation ```bash pip install numpy ``` No other dependencies. Single file, approximately 600 lines. ## Usage ### CLI ```bash python holo_silence.py python holo_silence.py --output results/ ``` Runs ten demonstrations. ### Python ```python from holo_silence import SilenceMemory mem = SilenceMemory(d=2048, loss_rate=0.01, seed=0) # Storage mem.observe(label, weight=1.0, **fields) # Time mem.step() # advance one tick mem.advance_iterative(n) # advance n ticks # Query r = mem.query(label) # PRESENT / GONE / UNKNOWN # Tombstones mem.tombstones_list() # all lost items mem.when_lost(label) # tick of loss mem.life_span(label) # ticks the item was alive mem.loss_log() # ordered by loss tick # Metrics mem.silence_ratio() # fraction of store gone mem.acceptance() # full breakdown mem.presence_by_age() # survival by age bucket (see paper for caveats) # Control mem.freeze() # pause loss mem.resume() # restore loss mem.set_loss_rate(rate) # Diagnostics mem.stats() mem.save_json("state.json") ``` ## Results All results at D=2048, loss_rate=0.02 unless noted. ### Self-test | Check | Result | |---|---| | bind/unbind identity | PASS | | observe + query | PASS | | loss at rate 1.0 | PASS | | tombstone recorded | PASS | ### Basic loss over time Twenty items, 150 ticks: | Tick | Present | Lost | Silence | |---|---|---|---| | 0 | 20 | 0 | 0.000 | | 25 | 11 | 9 | 0.450 | | 50 | 7 | 13 | 0.650 | | 75 | 4 | 16 | 0.800 | | 100 | 2 | 18 | 0.900 | | 150 | 0 | 20 | 1.000 | ### Long horizon Two hundred items, `loss_rate=0.005`, 400 ticks: | Tick | Present | Lost | Silence | Trace magnitude | |---|---|---|---|---| | 50 | 151 | 49 | 0.245 | 12.405 | | 100 | 116 | 84 | 0.420 | 10.686 | | 200 | 64 | 136 | 0.680 | 7.893 | | 300 | 40 | 160 | 0.800 | 6.303 | | 400 | 22 | 178 | 0.890 | 4.679 | The store empties. The trace magnitude shrinks. ### Loss log Named items, ordered by loss tick: ``` lost_at life label 1 1 forgotten_name 2 2 unfinished_book 6 6 summer_of_98 7 7 favorite_song 8 8 grandmothers_recipe 12 12 first_love 12 12 childhood_friend 27 27 broken_promise 34 34 the_old_house 52 52 last_conversation ``` ## API reference ### `SilenceMemory` ```python SilenceMemory(d=2048, loss_rate=0.005, threshold=0.05, seed=0) ``` **Storage** - `observe(label, weight=1.0, **fields)` — store an item. - `query(label, fields=None) -> dict` — three-state verdict. **Time** - `step()` — advance one tick. - `advance_iterative(n)` — advance n ticks. **Tombstones** - `tombstones_list() -> list[dict]` - `when_lost(label) -> int | None` - `life_span(label) -> int | None` - `loss_log() -> list[dict]` **Metrics** - `silence_ratio() -> float` - `acceptance() -> dict` - `presence_by_age() -> dict` **Control** - `freeze()` — pause loss. - `resume()` — restore loss. - `set_loss_rate(rate)` **Diagnostics** - `stats() -> dict` - `save_json(path)` ## Design notes ### Loss is independent of everything The Bernoulli trial at each tick uses a probability that does not depend on weight, age, or access count. Old items and new items are equally likely to be lost next tick. This property follows from the implementation. It is not directly measured in the demos (see paper §4.6). ### Loss is silent No event is emitted when an item is lost. The user discovers loss by query. This is intentional. The substrate does not notify; it just is. ### Tombstones preserve the fact of existence A tombstone holds the label, observed_at, lost_at, life_span, and weight_at_loss. It does not hold the composite vector. The item is gone; the marker remains. ### Rebirth is re-observation A lost item can be observed again. The new incarnation is not the old one. The tombstone is removed. The substrate does not distinguish the new incarnation from a fresh observation of the same label. ## Limitations **Not practical.** No recovery, no reason, no configuration. A design statement, not a tool. **Trace corruption.** Removing composites leaves residual signal. Over many losses the trace accumulates noise. **Tombstones unbounded.** Every loss creates a tombstone. Long runs accumulate them. **No way to forget a tombstone.** Lost items leave markers that cannot be removed. **Field-matched rebirth.** Re-observed items must be queried with matching fields. **No probabilistic survival model.** The substrate does not report the probability of an item surviving N more ticks. **Freeze is binary.** Individual items cannot be frozen. ## Citation ```bibtex @misc{holo-silence2026, title = {holo-silence: A memory substrate that loses things without reason}, author = {zeechimp}, year = {2026}, note = {Three-state query distinguishing PRESENT, GONE, and UNKNOWN. Tombstones record loss without explaining it.} } ``` ## References - Plate, T. A. "Holographic Reduced Representations." *IEEE Transactions on Neural Networks* 6:3 (1995), 623–641. - Kanerva, P. "Hyperdimensional Computing." *Cognitive Computation* 1:2 (2009), 139–159. - Klass, D., Silverman, P. R., Nickman, S. L. *Continuing Bonds: New Understandings of Grief.* Taylor & Francis (1996). - Boss, P. *Ambiguous Loss.* Harvard University Press (1999). ## License Apache 2.0