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

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:

{
    "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

pip install numpy

No other dependencies. Single file, approximately 600 lines.

Usage

CLI

python holo_silence.py
python holo_silence.py --output results/

Runs ten demonstrations.

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

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

@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