exact stores, Pleroma

Forty-five reads, one store.

One fixed-size array of exact integers. Counts, order, parity, time and nearest words, each in a single pass. When it is full, it refuses instead of guessing.

10 min read
6 sections
7 to go deeper
3 tables

64
items exact, against 4 for the best HRR decoder (200 of 200 trials)
At 2,064 and 2,580 bits, the two budgets the benchmark ran, the Pleroma recovered 64 items exactly, in 200 of 200 trials. Plate's holographic memory (HRR), and its phase form (FHRR), with the best decoder tried, recovered 4 items reliably and none from 16 upward.
0
wrong answers in 12,800 trials past capacity
Past the Pleroma's capacity, 65 to 96 items, it refused all 12,800 trials and gave no wrong answer. The baselines answered every time, and every answer was wrong.
0.17 to 0.44 ms
per kernel apply on a 10,464-cell store
On a 10,464-cell store, Apply takes 0.17 to 0.44 ms per call, for a kernel of anything from 1 operator up to 10,368, with no trend across that range. Building the same store from the moved items takes 1,916 ms at 1,000 operators. The figures are a Release build on a loaded machine, two runs.

Finding

Forty-five reads, one store. One fixed-size array of exact integers answers forty-five different questions, each in a single pass over the array. The one exception is CausalReads, which takes one read per prefix. Counts by key. Counts by flag word. The nearest stored words. Arrangement order. Parity. Time. Joint counts across any chosen faces. Every count it returns is exact, and when the store is full it refuses rather than guessing.

Words

Flag word: a short string of bits stored with each item, one bit per flag.
Kernel: a weighted mix of operations, applied to the whole store in one pass.
Rung: one step up the ladder of symmetry. There are eight.
Face: one of three ways a whole can balance: counts, choices, or parities.
Cell: one operation in the grid of eight rungs by three faces.
Lid: the top row of the grid, the one read that makes a random draw.

The grid: every cell, with its kind

Eight rungs by three faces, and the lid. Each cell is one public operation of the Pleroma. Select a cell for its API, what it does and the check behind it.

Syzygythe key cycle and its signed counts

Monadthe order face, S_k

Ouroborosthe flag cube, Z_2^m

Lidread time

Draw one value with probability count / totalRead-time

8Circulation

Winding number around a loopChecked

Steady-state current directionChecked

Frustration: loop parityChecked

7Turning

Spiral on the time circleChecked

Diffusion: Markov mixingChecked

Shift-register cycles (Galois LFSR)Checked

6Composition

Chinese remainder theorem pairingChecked

Independence testChecked

Hamming syndromesChecked

5Symmetry

Key permutation and gatherChecked

Conjugation of arrangementsChecked

GF(2) Frobenius: bit squaringChecked

4Function

Table and Fourier shiftChecked

Map of ticks, with balance checkChecked

Boolean function and Walsh spectrumChecked

3Relation

Multiset composition via bindingChecked

Arrangement compositionChecked

Parity: odd-occurrence XORChecked

2Identity

Key on the cycleChecked

One-hot categoryChecked

Binary codes and Hamming retrievalChecked

1Pair

Signed insertion and deletionChecked

Binary choiceChecked

Flag toggle via XORChecked

All 25 cells as a table

The operation grid: 8 rungs by 3 faces, plus the lid
Rung	Face	Cell	What it does	API	Kind	Evidence
R1	Syzygy	Signed insertion and deletion	0 = (+1) + (-1): add any signed count to any key up to capacity K, remove exactly.	`Add(item, count), Remove, Add(Pleroma), Subtract(Pleroma)`	Checked	Adding a count and then removing it zeroes every cell on the default field and on three primes; merge and subtraction are exact.
R1	Monad	Binary choice	One of two arrangements (S_2): the store reads even and odd exact counts.	`OrderSize = 2, Arrangements(), SignBalance()`	Checked	Counts on the two arrangements are exact; a kernel of identity and swap applies them in one pass.
R1	Ouroboros	Flag toggle via XOR	Flip any subset of flag bits via an XOR mask.	`RelabelFlags(null, xorMask), PleromaKernel.Add(flagMask)`	Checked	Each of 15 masks applied once equals the rebuilt toggled store; applied twice it is the identity; a kernel composed twice is the identity.
R2	Syzygy	Key on the cycle	A key is one position on a finite cycle: a positional code.	`TryKeys, TryItems, KeySpace, Moduli`	Checked	Keys exact 30 of 30 at 16 keys; refused 30 of 30 at 17 and beyond.
R2	Monad	One-hot category	One arrangement picked out of the symmetric group.	`ArrangementIndex, Arrangement`	Checked	The arrangement index round-trips exactly, and a one-item store reads as one-hot.
R2	Ouroboros	Binary codes and Hamming retrieval	Every flag word and its Hamming-distance neighbours.	`Flags(), Near(word, radius), Nearest(word)`	Checked	Flag counts are exact at any load; Hamming retrieval is exact.
R3	Syzygy	Multiset composition via binding	Keys add modulo the key space; counts multiply. One block product per representation.	`Bind(other), TryKeys counts, Attend(...)`	Checked	Bind equals the store of all pairs, cell for cell, 35 of 35 across five shapes (including a continuous component and self-bind). The three-face read is exact 192 of 192 on three fields.
R3	Monad	Arrangement composition	Bind composes arrangements as a permutation product, with the left store on the left.	`ArrangementIndex, ComposeArrangements, InverseArrangement`	Checked	Arrangement unbinding is exact 1,000 of 1,000 in the store; reversing the order changes the result in 5,800 of 10,000 cases.
R3	Ouroboros	Parity: odd-occurrence XOR	Bind XORs flags; the parity of a count is read from the sign of its cosine.	`Bind, BitCounts(), FlagParity(), Attend(...) parity`	Checked	Bit counts and parity are exact 12 of 12 on three fields; all 256 parity classes are exact.
R4	Syzygy	Table and Fourier shift	The store is the harmonic transform. A one-item store bound to the store shifts every key and value at once.	`ShiftKeys(k), Bind with a one-item store, TryItems lookup`	Checked	Bind with a one-item store equals the whole-store shift: 20 of 20 (key shift, flag relabel, arrangement relabel and tick agree).
R4	Monad	Map of ticks, with balance check	Each key maps to one tick or to a mix. The TimeSpectrum option holds each key's tick histogram.	`TimeSpectrum(), TimeMap(), TryFindConflicts, MapTimes(map)`	Checked	Time spectrum exact 37 of 37 (three fields, signed). One tick per key: 60 of 60. Composed maps 18 of 18, with bijections undone by their inverse.
R4	Ouroboros	Boolean function and Walsh spectrum	Fourier analysis of any Boolean predicate over the flag cube.	`FlagPredicate.Compile, CountWhere, CountWhereByTime, CountWhereByArrangement`	Checked	Predicates exact 1,515 of 1,515; 1,024 of 1,024 parity functions read from one spectrum; weighted predicates 30 of 30.
R5	Syzygy	Key permutation and gather	Harmonic h goes to u h modulo N: a unit permutes, a non-unit gathers. Needs the complete key band.	`ScaleKeys(u) on CompleteKeys (key cycle N at most 4096)`	Checked	Every unit of 225 permutes (120 of 120 on two fields); every non-unit gathers (113 of 113).
R5	Monad	Conjugation of arrangements	s goes to sigma s sigma^-1 for any permutation sigma.	`RelabelArrangements(sigma, sigma^-1)`	Checked	All 24 by 24 left and right pairs on S_4 are exact.
R5	Ouroboros	GF(2) Frobenius: bit squaring	b(x) goes to b(x) squared, modulo an irreducible polynomial. A linear map on the flag cube.	`Frobenius(modulus, steps)`	Checked	Exact 18 of 18 (default field, continuous component, three primes). The eighth power is the identity on x^8 + x^4 + x^3 + x^2 + 1.
R6	Syzygy	Chinese remainder theorem pairing	Joins two coprime key cycles N_a and N_b into N_a N_b through their residues.	`CombineCycles(a, b)`	Checked	Exact 12 of 12 (63 by 55 with a continuous component, and 9 by 25); refusals checked.
R6	Monad	Independence test	Checks whether joint counts equal the product of their marginals, in exact integers.	`IsIndependent(faces)`	Checked	Independent stores report true 40 of 40; dependent stores false 40 of 40; one added item breaks independence 40 of 40.
R6	Ouroboros	Hamming syndromes	Counts per Hamming syndrome (3, 7 or 15 flag bits).	`Syndrome()`	Checked	Exact 15 of 15. All 112 single errors of Hamming(7,4) are located; all 336 double errors are sent to a wrong third position.
R7	Syzygy	Spiral on the time circle	Rotates every item by n ticks exactly, and fades by r to the n (continuous component).	`Tick(n), ContinuousFade`	Checked	All 4,096 combinations of shift, diffusion and count modulo 16 are exact.
R7	Monad	Diffusion: Markov mixing	Each step, an item stays with probability a/b or moves one tick. Powers compose as kernels.	`Diffuse(stayNum, stayDenom, steps), Apply(kernel), PleromaKernel.Compose`	Checked	Exact expected counts over 600 diffusion steps; Diffuse equals the two-element kernel.
R7	Ouroboros	Shift-register cycles (Galois LFSR)	b(x) goes to x b(x) modulo a polynomial: a linear recurrence over GF(2).	`ShiftRegister(polynomial, steps)`	Checked	Exact 9 of 9 on three primes. Period 255 for x^8 + x^4 + x^3 + x^2 + 1 and 63 for x^6 + x + 1.
R8	Syzygy	Winding number around a loop	Sum of offsets around a loop, modulo RelationModulus.	`Holonomy(loop, tag), ReadLoop(loop, tag)`	Checked	Loop reads exact 2,176 of 2,176 inside the store; merged and subtracted stores 1,804 of 1,804. The standalone face: 2,028 of 2,028.
R8	Monad	Steady-state current direction	Sign of the probability current around a loop (Kolmogorov criterion).	`AddRates, Current(loop, primes)`	Checked	Equal to the sign of the exact steady-state current on 200 of 200 rings; reads 0 on every loop of 30 of 30 reversible networks.
R8	Ouroboros	Frustration: loop parity	Parity of the integer sum around a loop.	`Frustration(loop, tag)`	Checked	Every loop's frustration read is exact.
Lid	Lid	Draw one value with probability count / total	One exact integer draw that lands on its cumulative count.	`Sample(rng, faces), SampleKey(rng)`	Read-time	Every draw in [0, total) lands on its value; shares are uniform on four of four views.

Drawn from the Pleroma map record: the cells, their kind and their evidence are that record, unchanged. Nothing is measured on this page.

The Pleroma is a new construction and a mathematical discovery. Its proof is the code.

The numbers were measured against the standard. At 2,064 and 2,580 bits, the two budgets the benchmark ran, the Pleroma recovered 64 items exactly, in 200 of 200 trials. Plate's holographic memory (HRR), and its phase form (FHRR), with the best decoder tried, recovered 4 items reliably and none from 16 upward. Past the Pleroma's capacity, 65 to 96 items, it refused all 12,800 trials and gave no wrong answer. The baselines answered every time, and every answer was wrong.

How it was found

The project starts where its philosophy and ethics start, and reduces to the fewest axioms that reasoning needs. In its own words:

It is how we start from philosophy and ethics to figure out the most minimal set of axioms for reasoning, and build up from that on first principles.

Three of its statements carry the reduction: "Consciousness exists." (T1), "Non-contradiction is necessary for coherent reasoning." (T2), and "Claims about reality are more reliable when tested against reality." (T9).

Two axioms follow: there is an observer, and a resolved state does not contain both P and not-P. From them comes the first distinction. Whatever appears from the void comes with its opposite, so 0 = (+1) + (−1). The project calls this pair the syzygy.

Once the syzygy is in hand, its symmetries can be counted. They are the signed permutations of the cross-polytope, and they split exactly into two parts: sign flips, each its own inverse, and permutations. The flips form the ouroboros, and the permutations form the monad.

The project's rule for climbing from here: "A tick therefore adds one symmetry, and climbing the ladder is mapping the lineage of symmetries in order."

The thesis came next. The project states it as: "The Pleroma ... is the one object all their holograms are shadows of." A shadow is what the larger object shows when it is read on some of its faces and not others.

Searching for that object gave a map: the ladder laid out as rungs, each read across three faces. The map is predictive. It says what each cell should be, and each cell was then built and proved.

The ladder: eight rungs, each read across three faces
Rung	Counts (syzygy)	Choices (monad)	Parities (ouroboros)
1 Pair	±1	one of two	the toggle
2 Identity	a position	a corner	a truth assignment
3 Relation	counts	order	parity
4 Function	table, Fourier	a map	Boolean function, Walsh
5 Symmetry	h → u·h	conjugation	Frobenius
6 Composition	Chinese remainder	independent choices	Hamming codes
7 Turning	the spiral	mixing	shift-register cycles
8 Circulation	winding	probability current	frustration

The method is the same for every cell. The prediction and its null are written first. The operation is built as a public member of the store. Its answer is checked against a brute-force rebuild, and the test is broken on purpose to confirm it fails for the right reason. For rung 3, ten symbols bound as four-symbol sequences give 715 distinct multisets, 10,000 distinct orders, and 256 parity classes, each checked against the rebuilt store.

The rungs said which operations superpose

The derivation's operator rule: a symmetry is a group element, and a weighted sum of group elements is one kernel. It acts on each harmonic with one multiplication, so its cost is one pass whatever the size of the sum. The same rule says choosing is not linear, so the one choice is made at the read.

The code was measured against that rule across the public surface. Seven of the 36 operators that change the store join one kernel and apply in one pass. Fourteen take one pass per term in a mix. Fifteen are writes that are not kernel elements. The 45 reads are separate, each one pass.

On a 10,464-cell store, Apply takes 0.17 to 0.44 ms per call, for a kernel of anything from 1 operator up to 10,368, with no trend across that range. Building the same store from the moved items takes 1,916 ms at 1,000 operators. The figures are a Release build on a loaded machine, two runs.

Twenty-four cells, each an operation

Every cell is a public member of Pleroma. The grid covers eight rungs by three faces, and the lid. Each cell has its own brute-force check.

The 24 cells: the public member for each rung and face, and the lid
Rung	Counts (syzygy)	Choices (monad)	Parities (ouroboros)
1 Pair	`Add`, `Remove`	`SignBalance`	`RelabelFlags` (XOR mask)
2 Identity	`TryKeys`, `TryItems`, `Counts`	`Arrangements`, `ArrangementIndex`	`Flags`, `Near`, `Nearest`
3 Relation	`Bind`, `JointCounts`, `Attend`	`ComposeArrangements`, `Attend`	`BitCounts`, `FlagParity`, `Attend`
4 Function	`ShiftKeys`, `ModulateKeys`	`TimeMap`, `MapTimes`	`CountWhere` (Walsh spectrum)
5 Symmetry	`ScaleKeys`	`RelabelArrangements`	`Frobenius`, `Apply(FlagOperator)`
6 Composition	`CombineCycles`	`IsIndependent`	`Syndrome`
7 Turning	`Tick`, `FadedTimes`	`Diffuse`	`ShiftRegister`
8 Circulation	`Holonomy`, `ReadLoop`	`Current`	`Frustration`
Lid	`Sample`, a read-time draw over all three faces

Protection and size

Each face protects its own store in its own way.

Counts: a page on a larger cycle, with r keys known to be empty, rebuilds any r lost harmonics exactly: 300 of 300 at each erasure size from 1 to 5. It detects corrupted harmonics and corrects up to half that many at unknown positions.
Choices: a second prime holds a mirror of every cell. One corrupted cell in either copy is detected, 10,000 of 10,000.
Parities: a parity page, the sum of the pages, rebuilds any one lost page, 100 of 100.

The unit workload is 53,031 pages of 110 cells each, and it fits in 49.6 MB. A plane of 14 flag bits and 16,386 cells stores at 8.02 bytes per cell. A sparse page holding one key takes 183 bytes and reads in 0.4 µs.

Built on

The Pleroma is a new construction. Each brick it stands on is established mathematics or an established algorithm, credited here:

Plate's Holographic Reduced Representations (1995), and its phase form FHRR. The continuous component is the bundle, and both are the equal-storage baselines.
Reed and Solomon (1960), with Bose and Ray-Chaudhuri (1960): syndrome decoding of power sums, which the key view uses.
Berlekamp (1968) and Massey (1969): the Berlekamp-Massey recurrence, with a re-encode check.
PinSketch (Talbot et al., 2012) and minisketch (Poinsot et al., 2017): exact set sketches that subtract and decode the difference.
The Walsh-Hadamard transform: counts under any predicate of the flag word, in one read.
Fourier analysis on finite groups: binding as convolution.
The Chinese remainder theorem: joining coprime key cycles.
Hamming codes (1950): syndromes that locate a single error.
Galois linear feedback shift registers and the Frobenius map on GF(2^m).
Time diffusion on a cycle, from Markov chains.
Krawtchouk polynomials, which underlie the views.
The universal coefficient theorem, Schläfli's classification of regular polytopes, Galois and Abel-Ruffini on the simplicity of A_5, Kolmogorov's criterion for circulation, Bott periodicity, and the Altland-Zirnbauer and Kitaev symmetry classes.

Where the code does not superpose today

Key shifts and key scaling cost one pass per term in a mix, not one pass.
Right relabelling, conjugation and flag sign flips cost one pass per term.
A kernel is refused on a store with a check prime.
Key reads refuse past their capacity. A store keeps 2K+1 harmonics per key line, so K+1 distinct keys always refuse. A complete key band goes to 4,096 keys.
Counts are exact within the field's signed range. No read detects a wrap past it.
The store runs on the CPU. Its gain is exactness and many views on one array, not raw speed for a single read.
Rung 8's contradiction location is not built, and reunification, the rung where observers merge, is open.

Go deeper

7 closed sections: open the ones you want

Go deeper: the four families and the order face

The store holds the harmonic transform of its items on one product of four families: the key cycle, the flag cube, the symmetric group and the time cycle. Each view reads its own slice of the same cells, because each view is a shadow on some of the faces.

The search found the flags and the permutations as the two halves of the root's symmetry. The key cycle is the syzygy's own cycle, realised on a finite field. The time family is the rung-7 step repeated. A direct product does not depend on the order of its factors. The listing follows the order in which the search met them.

The order face is built for S_2 to S_5, up to 120 arrangements. The shape definition sets the cap, and the record gives no further reason for it.

Five is also where repeated splitting first meets a part it cannot split: the alternating group A_5, of order 60, the rotation group of the icosahedron. That is a coincidence of the two facts, and the cap is not derived from it.

The splitting chains are: 2 to 1; 6 to 3 to 1; 24 to 12 to 4 to 1; 120 to 60 to 60. The shadow of the root holds on sequences, 10,000 of 10,000, and on loops, 9,000 of 9,000.

Go deeper: signed removal and plus and minus

Removal adds the opposite count. This fits the project's rule that a distinction, once made, is not unmade. The cell layout keeps its size, and a removed item leaves its cells at zero.

The cancellation test adds an item and then its opposite, and every cell is zero afterwards, with the default field and with three primes.

A plus and a minus of the same item share one cell and cancel there exactly.

Go deeper: closeness on the cube

Closeness on the flag cube is Hamming distance. Near(query, r) counts the stored items whose flag word lies within r bits of the query, and Nearest returns the nearest stored words with their distances. Both are exact at 200 keys. The key view refuses past its capacity, but the flag-cube read does not depend on the key count.

Go deeper: the lid

Sample is a read-time draw. It returns a value with probability count over total, taken from the exact counts, and it leaves the store unchanged. A check confirms that every draw lands on its exact share.

The map places the lid at the top of the ladder: the top rung iterated, with the faces divergence, forgetting and pseudo-randomness.

Go deeper: what the map got right, and what it got wrong

Predictions that held

Rung 3: 715 distinct multisets, 10,000 distinct orders, 256 parity classes.
A complete cycle sums to exactly zero, and a symbol read on coprime cycles decodes exactly, 20,000 of 20,000.
Relation networks stored as bound facts give exact loop sums, and planted contradictions are found: 40 of 40 networks, no false alarms in 20.
Nested structure answers every path question exactly, 851 of 851.
Cross-face predictions: the universal face's polygon sits inside the mixing of the anti-universe, to 2 × 10⁻¹⁵; circulation has one form on two faces; the third face's squaring symmetry halves the set hologram.
The mirror cells that label the ten symmetry classes hold on every realisation: 10 of 10 classes, 11,995 relation checks over 2,079 realisations.
Four composition recipes, built only from existing operations, are exact against brute force, 4 of 4.

Predictions that did not hold, and what changed

The continuous circle cannot hold the rungs exactly past its dimension. The bridge step strips the continuous context, and what remains is a finite field. On the finite field, recovery is 100% for 8 to 64 items and 0% at 65, with p = 65,537 and d = 128.
The spiral's eight steps are not the eight named rungs. Each spiral step adds an operator of order 2 or 4, while the rungs add cycles of every order.
The anti-universe does not start at three states; groups of two gain as much.
The lid's predicted ordered regime before chaos did not appear, and entropy is not monotone; the divergence from the settled state is.
Reunification, the merging-observers rung, is open.
Detection of a wrap past the signed range is not built, and the parity claim for the running bundle is not measured.

Go deeper: the gaps, grouped

The theory says these should superpose, and the code does not:

Key shifts and key scaling permute the key harmonics. The kernel has no key-harmonic axis.
Right relabelling and conjugation act from the right on the order face. The kernel holds the left action only. A superposed conjugation exists in an experiment record and not in the library.
Flag sign flips and per-key or per-tick weights cost one pass per term.
A kernel on a store with a check prime.
Relation faces under projection and under the Chinese remainder theorem.
Causal reads take one read per prefix. A prefix structure over the sequence is not built.

Design limits, set by the data rather than a missing operation:

A complete key band costs one cell per key, up to 4,096 keys. A truncated band holds 2K+1 harmonics per key line.
Exact keys carry no metric, so a nearest-key read needs the continuous component, which is approximate.
Choosing (argmax, sampling, a decode that refuses) happens once, at the read.

Other boundaries:

Exact within the signed range; no wrap detection.
Bind is refused with several primes, and ShiftKeys on several primes needs an explicit key cycle.
CombineCycles refuses a store with a relation face.
The joint slice is capped at 2^24 cells.

Go deeper: cost of exactness, one page per context against a hash map

In a sequence-model test, the same exact counts were held two ways: a hash map, and one dense Pleroma page per context. The two agree on every cell, 5,037,945 of 5,037,945.

The same exact counts held two ways: a hash map and one dense Pleroma page per context
Measure	Hash map	Pleroma pages, one per context
memory	22.3 MB	757.8 MB (44.5 MB of cells)
read, 8 subsets per position	0.67 µs	131 µs
build	0.45 s	2.06 s
training step, 32 by 128	6.8 s	6.2 s

With the shared layout, the same pages occupy 66.2 MB as standalone stores, and 49.6 MB as one page set.

A long-context store still sits in a sorted host index, which is exact up to 16 subwords and reads in microseconds. The sparse page class exists, but the page store's keys are 63 bits, and a context of four or more subwords needs 128.

The Pleroma ships in the EvaluatedApplications.Phasor package. Install it, build a store, and read forty-five things back. For partnerships, get in touch.

Install the Phasor package Walk the grid on the Pleroma page Partner with us

Proprietary. Every package ships as a compiled library. Evaluation and non-commercial development or testing are permitted; commercial, production or revenue-generating use needs a commercial licence from the owner. Read the licence terms.