# 🌌 Cosmos — the cosmo-quantum memory core (classically real)

> Two ideas drawn from a Big-Bang / quantum-mechanics vision — kept only where they
> survive contact with a classical machine and a measurement. The fiction is refused;
> the transferable structure is kept and proven.

## The honest reframe (DIAKRISIS)

The vision was quantum: knowledge that "inflates like a Big Bang," an "entangled
spacetime memory" that "sees the future with zero error." The literal physics can't
run on a CPU, and "never wrong" is unfalsifiable — so we keep the **two ideas that DO
transfer** and make them measurable. This is **quantum-inspired structure on classical
math** — not quantum compute, not precognition.

## ① The Singularity Codec — compress, then inflate only what a problem needs

Instead of dumping your whole memory into context, **compress** all accumulated
context into a dense, deduped seed (the "singularity"), then **inflate** only the
slice a given problem needs (the "inflation moment"), then collapse (stateless).

A fact is inflated only if it shares a **discriminating** entity with the problem —
generic, low-information links (an entity that appears in most facts) are filtered by
**IDF**, which is what keeps a distractor out.

```bash
mneme cosmos inflate --problem "fixing the auth token refresh"
#  🌌 inflated 2 relevant facts — examined only 3/14 of the seed (21%)
```

| measured | result |
|---|---|
| **inflate-precision** | **1.0** — never expands an irrelevant distractor (0 leaks) |
| inflate accuracy | **≥ 0.985** on a labeled corpus |
| sub-scan | examines **< the whole seed** (a problem-shaped pocket, not a full read) |

## ② Entangled-Gravity retrieval — fall toward the densest relevant cluster

Memories are **entangled** by shared entities / citations into a graph; each cluster
has **mass** (local density). A query falls toward the densest relevant cluster
("semantic gravity"), reaching the right memories while **visiting far fewer nodes
than a full scan** — and its top-k matches a brute-force baseline.

```bash
mneme cosmos gravity --query "payments ledger"
#  🌌 pulled 2 memories — visited only 2/8 nodes (25%, the gravity well)
```

| measured | result |
|---|---|
| **top-k agreement vs full scan** | **≥ 0.985** |
| sub-scan | visits **< total nodes** (the gravity well, not the whole graph) |

`cosmosGauntlet = 100`. MCP: `mneme.cosmos.inflate` · `mneme.cosmos.gravity` (every
agent, Matrix gRPC auto). Both run over your repo's accumulated context
(`.mneme/passport`) — the "instinct core" over the memory your agents build.

## Why it was a black sheep

Today's AI is built on statistics and vector space. These two engines are built on
**information theory (IDF) + graph mass** — a different lens that most pipelines skip
because "knowledge that inflates on demand" and "memory with gravity" sound too strange.
They're not magic; they're a real **compress/expand** codec and a **mass-weighted
graph pull**, measured to the bar the rest of Mneme is held to.