Phasor: exact holograms and vector-symbolic computing for .NET

Phasor's main object is the Pleroma. An item is a key plus, optionally, a flag word of up to 16 bits, an arrangement of up to 5 things and a tick on a clock. One array of finite-field harmonics answers exact counts per key and whole items (refusing past the key capacity), exact counts per flag word, how many items lie within r bits of a query and which stored words are nearest, counts per arrangement, counts per tick, and opt-in joint counts over flags, order and time. Everything except the key views stays exact at any load.

The whole store relabels, shifts keys, ages and diffuses over time in place with every view still exact, and a weighted superposition of flips, relabellings and time shifts applies to the whole store in one pass. Under the Pleroma is the phasor codec, a vector symbolic codec that encodes numbers and symbols as unit-complex faces and composes them with bind, unbind, bundle and correlate.

• Exact where others approximate

  At equal storage, the exact key view recovered 64 items with no errors where Plate's holographic reduced representations held 95% or better only up to 4. Past capacity it refuses, where the baseline answers wrongly every time.

• One array, many questions

  Counts per key, flag word, arrangement and tick, nearness, joint counts and any predicate are read from slices of one array, so adding a view does not add a second store.

• Whole-store operations in one pass

  A weighted superposition of flips, relabellings and time shifts applies to every item at once, at a cost that does not depend on how many elements the kernel holds.

using Phasor;

var store = new Pleroma(new HologramShape
{
    KeyCapacity = 16,                                       // whole items come back for up to 16 distinct keys
    FlagBits = 8,                                           // an 8-bit flag word per item
    TimePeriod = 63,                                        // a 63-tick clock
    JointFaces = HologramFaces.Flags | HologramFaces.Time,  // also store flags x time joint counts
});
store.Add(new HologramItem(Key: 1001, Flags: 0b0000_0101, Time: 0), 3);
store.Add(new HologramItem(Key: 2002, Flags: 0b1000_0001, Time: 5), 2);

if (store.TryItems(out var items))                          // refuses past 16 keys instead of answering wrongly
    foreach (var (item, count) in items)
        Console.WriteLine($"{item.Key}: flags {item.Flags}, time {item.Time}, count {count}");

long[] perFlagWord = store.Flags();                         // exact at any load
long near = store.Near(0b0000_0100, radius: 1);             // items whose flags differ from 0b100 in at most 1 bit
long[] joint = store.JointCounts(HologramFaces.Flags | HologramFaces.Time);   // index = word * 63 + tick
Console.WriteLine($"{perFlagWord[5]} {near} {joint[5 * 63 + 0]} {joint[129 * 63 + 5]}");

store.Diffuse(stayNumerator: 1, stayDenominator: 3);        // each item stays with probability 1/3, else moves one tick
long[] perTick = store.Times();                             // TimeScale (3) times the exact expected counts
Console.WriteLine($"scale {store.TimeScale}: {perTick[0]} {perTick[1]} {perTick[5]} {perTick[6]}");

1001: flags 5, time 0, count 3
2002: flags 129, time 5, count 2
3 3 3 2
scale 3: 3 6 2 4

This is the complete program, compiled and run against the published package.

• Views of one store

  TryKeys and TryItems for exact counts per key and whole items, Flags, Near and Nearest for flag words and closeness, Arrangements and SignBalance for order, Times for ticks, and JointCounts over any set of faces.

• Any predicate, one read

  CountWhere counts the items whose flag word satisfies any predicate, linear or not, exactly and at any load, with one inner product. Attend returns exact counts, shares and parity from one read.

• Whole-store operations

  Tick and Diffuse age every item, RelabelFlags, RelabelArrangements and ShiftKeys relabel the store without reading items back, and a PleromaKernel applies a weighted sum of such moves in one pass.

• Bind two stores

  Bind adds keys, XORs flags, composes arrangements and adds ticks for every pair of items at once. Binding with a one-item store shifts the whole store on every face together.

• Pages, sparse and dense

  A dense page reads every one of up to 4,096 slots exactly in one transform, and joins two pages exactly in one read. A sparse page holds exact counts over a huge key set in memory proportional to the keys present.

• Redundancy and repair

  Reserved keys detect and repair lost harmonics, a mirror in a second prime detects corruption in either copy, and an exact-sum parity rebuilds any one lost store.

• Keys only

  CycleHologram is the Pleroma with keys only. It returns every stored symbol and count exactly up to its capacity, refuses past it, and adds and subtracts exactly, so two replicas can find what differs by exchanging one small hologram.

• The phasor codec

  PhasorCodec, HoloCodec and Hologram encode numbers and symbols as faces and compose them with bind, unbind, bundle and correlate. One operator set works on numbers, text and their mixtures.

• There is no key-addressed attention. The key view returns exact whole items up to capacity. It is not a similarity search on keys.
• A store of key capacity K holds 2K+1 harmonics per key line and decodes up to K distinct keys. Past that it refuses.
• Counts must stay within the field's range. On a small prime field, weighted queries scale counts by the weight, so keep totals times the weight below half the field.
• The Pleroma runs on the CPU. There is no GPU kernel.
• It is a data structure and a set of operations, not a trainable embedding engine. The continuous phasor bundle is the approximate store; the Pleroma is the exact one.
• Exact arithmetic is not faster in general. A Pleroma read costs one or more transforms, while a float bundle read is one correlation. At equal bits float reads are often faster, and at large loads the two converge.
• The two codec layouts do not mix. Hologram and PhasorCodec use the interleaved layout, HoloCodec the planar one.
• PhasorCodec needs an even dimension of at least 128.

Every public type is documented with a worked example in the package readme on NuGet. Open the NuGet page.

items recovered exactly, against the baseline's 95 percent point, at equal storage

64 against 4

queries refused past capacity, none answered wrongly

12,800 of 12,800

exact recall up to 32 stored pairs, against 21.9% for the float bundle

100%

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.