generalist · recurrent
Torus Recurrent
Thick ring with 12 boundary ports. The recurrent reservoir keeps signal circulating and composes many weak constraints. Tuned with high proposal gain for low-bit and residue collars.
OMEGA · optical chamber federation · pre-hardware simulation
Three glass chamberssplit a number into its factors.
Pick a large number. Splitting it back into the two smaller numbers that were multiplied to make it is famously hard: it is the same problem that protects most of the encryption on the internet. OMEGA tries a different approach. It sends light into three specially shaped chambers at the same time. Each chamber checks one thing about the answer. Wrong guesses cancel each other out like ripples on a pond. The correct guess is the one bright spot left standing, and a tiny calculator at the end confirms it by simple multiplication.
On the search costs that dominate a 2048-bit factorisation, the bright-light version of OMEGA is estimated to run roughly 10^9 to 10^12 times faster than a high-end GPU cluster doing the same sieve, because one shot replaces a billion-plus arithmetic steps with one transit of the glass. The single-photon, quantum superposition version adds another exponential layer on top of that, in the same complexity class as Shor's algorithm: the cost scales with the number of digits in the key rather than the number of candidates. Both numbers are upper bounds from the simulator on this page, not measured optical hardware.
three chambers, three checkswrong guesses cancel outa final calculator confirms
scroll
§1 · what each chamber is and what it checks
Three glass shapes, three different questions about your number.
Start with a number, call it N. The goal is to find the two smaller numbers that were multiplied together to make it, call them p and q. OMEGA does not hunt for the answer one guess at a time. It builds three differently shaped glass chambers and shines light through all of them at once. Each shape is chosen so that the way light bounces around inside it answers one simple question about a guess. That binding between the shape and the question it answers is what we call the chamber's collar. More on chamber collars.
chamber 01 · light path
C₁ · torus · cyan
observer chamber 01
The doughnut: does the answer end in the right digits?
A doughnut-shaped chamber with twelve ports around its rim. Light enters one port and loops around the ring, passing the same boundary again and again. Each lap is one check.
What it tests: whether the candidate's last few binary digits match N's last few binary digits. If N is odd its last bit is 1, so p × q must also be odd. That fact eliminates half the candidates on its own. The torus stacks this test at widths of 2, 4, 8, 16, 32, 64 and 128 bits. A true factor passes every width. A near-miss fails almost immediately.
Analogy: a checksum done with light. The loop is the "again, and again" of repeated verification.
chamber 02 · light path
C₂ · icosahedral · amber
observer chamber 02
The crystal: are the two factors roughly the same size?
A perfectly symmetric body with twelve vertex ports. Light hops from vertex to vertex along its internal chords, sampling the chamber from every direction equally.
What it tests: whether p and q are roughly the same size, i.e. both close to √N. The two factors of a hard composite usually are. A pair like (3, 130) dims. A pair like (17, 23) brightens.
Analogy: a balance scale. The chamber's symmetry is the pivot.
chamber 03 · light path
C₃ · 3-arm plate · violet
observer chamber 03
The three-arm plate: do the small leftovers match?
Three arms of deliberately different length around a shared core. Light enters one arm, passes through the core, and exits another arm. Each arm has a different optical path length, so the chamber produces three independent readings at once.
What it tests: whether p × q and N leave the same remainder when divided by small primes 3, 5, 7, 11, 13. A true factor agrees on every remainder. This catches pairs that look "balanced enough" to the Echosahedron but fail to multiply back to N.
Analogy: three judges with slightly different scoring rules. A real factor wins all three. An impostor trips at least one.
§2 · why wrong guesses fade away
Wrong guesses do not get voted down. They cancel themselves out, like ripples on a pond meeting from opposite directions.
1 · every guess becomes a wave
Every possible pair of factors is sent through the chambers as a tiny light wave. The shape of the chamber nudges that wave forward or backward depending on whether the guess passes that chamber's check.
2 · wrong guesses point every which way
A wrong guess gets nudged in a different direction by each of the three chambers. When the three waves arrive at the meeting point they are pointing all over the place, and they add up to roughly nothing. The wrong guess simply goes dark.
3 · the right answer lights up
The correct pair of factors passes all three checks, so the three waves arrive pointing the same way. They stack on top of each other and produce one bright spot, much brighter than anything else. That bright spot is the answer.
It is the same effect as noise-cancelling headphones (sound waves that disagree silence each other) and lasers (light waves that agree pile up into a beam), pointed at arithmetic instead of sound or light. More on where the waves meet.
§2b · From soft score to wave amplitudeHow a numerical score becomes a phasor,
How a numerical score becomes a phasor,
and how three phasors sum on the lattice.
The previous section claimed that wrong candidates "decay by interference". Here is the explicit construction. Each chamber encodes its score s ∈ [0,1] as a complex amplitude A = s · e^(i(1−s)α): magnitude is the score, phase shift from the chamber's reference grows as the score drops. The bulk lattice writes the vector sum Σᵢ Aᵢ at each candidate cell. The cell's brightness is |Σ|².
True factor (17, 23)
all three collars near 1.0 → phasors align
|Σ| = 2.95 · Σ|·| = 2.96
coherence = |Σ| / Σ|·| = 1.00
coherence = |Σ| / Σ|·| = 1.00
C₁ torus1.00
C₂ echo0.96
C₃ mixer1.00
Near-miss (15, 26)
torus fails parity → C₁ phasor rotates away
|Σ| = 0.92 · Σ|·| = 0.92
coherence = |Σ| / Σ|·| = 1.00
coherence = |Σ| / Σ|·| = 1.00
C₁ torus0.00
C₂ echo0.92
C₃ mixer0.00
Off-factor (3, 130)
imbalanced + wrong remainders → phasors scatter
|Σ| = 0.45 · Σ|·| = 0.45
coherence = |Σ| / Σ|·| = 1.00
coherence = |Σ| / Σ|·| = 1.00
C₁ torus0.00
C₂ echo0.45
C₃ mixer0.00
Read the diagrams as tip-to-tail vector addition. Each coloured arrow is one chamber's amplitude. The dashed white arrow is the sum. The coherence number |Σ|/Σ|·| ∈ [0,1] measures alignment. A value of 1 means the three vectors point the same way and the lengths fully add. A value near 0 means they cancel.
For the true factor (17, 23) all three scores sit at essentially 1, all three phases at 0, and the sum vector reaches close to length 3. For an off-factor candidate the phasors rotate away from the reference axis and partially cancel, so the sum is short. The bulk lattice's bright ridge is the locus where this vector sum is long.
The cube-root combination shown in §3 is the scalar shortcut of this geometry. When phases align it behaves like the magnitude of the sum. When phases scatter, the small chamber scores dominate the product and the result collapses.
§3 · why this is faster than a normal computer (or a normal optical machine)
Three ways of looking for the same answer, only one of which looks at every guess at the same time.
The reason OMEGA is worth building is not that light is fast, though it is. The reason is that the chambers do not check one guess and then the next. They take all the guesses at once and let physics throw away the wrong ones for free. It helps to see this next to the two more familiar ways of doing the same job.
approach a
Silicon, one guess at a time
A normal computer chip is a very fast clerk with a calculator. To split a number, it picks a guess, multiplies, checks, throws it out, picks the next guess. The chip is fast, but the list of guesses for a real-world encryption key is astronomically long. Even a million clerks working in parallel cannot put a dent in it.
cost grows roughly with the number of guesses
approach b
Old-style optical, one beam, one guess
Earlier optical machines did speed things up: they swapped the electronic calculator for a light pulse, which is faster than any transistor. But they still asked one question at a time. One pulse, one guess, one check. You gain a constant speed-up, maybe a thousand times faster, and then you hit the same wall.
faster per step, same number of steps
approach c
OMEGA, all guesses in one go
OMEGA sends every possible guess into the chambers in the same flash of light. Each guess is one wave. The chambers do not pick them off one by one. They let the wrong waves cancel each other out, all at the same time, in a single pass.
Whether you are looking at a hundred guesses or a hundred trillion, the light still takes one trip through the chambers. The hard part stops being how many guesses there are and starts being how cleanly you can build the glass.
cost barely grows with the number of guesses
§3a · where the orders of magnitude come from
A CPU or GPU cluster does the same work the chambers do, but it has to do it one arithmetic step at a time, and it has to pay for every step in electricity and heat.
A CPU core can do a few billion small arithmetic operations per second. A high-end GPU can do tens of trillions, by running tens of thousands of tiny cores in parallel. That sounds like a lot until you write down the size of the search. A 2048-bit encryption key has on the order of 10^300 possible factor pairs. Even if every GPU ever built were checking guesses together since the start of the universe, the dent in that number would be invisible.
The chambers do not check guesses. They add up complex numbers, one per guess, in a single physical event. When light passes through a piece of shaped glass, every wavelet in the beam picks up a small phase shift and then sums with every other wavelet at the exit. That sum is exactly the calculation a CPU would do in a loop: take a candidate, compute a phase, add it to a running total, repeat. The glass does the whole loop in one pass at the speed of light, for free, with no clock ticks between the terms.
The speed-up comes from three places stacked on top of each other. First, parallelism: every candidate is a separate wave riding in the same beam, so a single shot covers what a CPU would have to walk through serially. Second, no memory traffic: a GPU spends most of its time moving numbers between registers, caches and main memory, and that movement is what limits real throughput. The chambers have no memory. The intermediate values exist as the light itself and never have to be written down. Third, no clock: the calculation finishes in the time it takes the light to cross the glass, which is a few hundred picoseconds. There is no instruction stream and no scheduler.
Put numbers on it. A GPU cluster searching a candidate space of a billion entries needs roughly a billion multiply-add cycles, spread across its cores, and pays for every one of them in joules. A single OMEGA shot processes the same billion entries in one transit of the chambers, using the energy of one laser pulse. The ratio between those two numbers is where the orders-of-magnitude claim lives. It is not that photons are faster than electrons by a small factor. It is that the chambers do not have to take the steps at all.
The cost the chambers do pay is precision in the glass. Every candidate has to land on the right phase to within a small fraction of a wavelength, or the wrong waves will not cancel cleanly. That is the engineering problem the rest of this page is about. It replaces the silicon problem of doing too many arithmetic steps with the optical problem of building one very accurate piece of glass.
§3b · the single-photon version
What if, instead of a flash of light carrying all the guesses, you sent in a single particle of light?
A photon is the smallest possible amount of light. One bullet. The strange thing about it is that, before anyone looks at it, a single photon does not have to choose which path to take. It spreads itself out over every possible path through the chambers at the same time. This is called superposition. It is the same effect that makes a single electron, fired at two slits, produce a stripey pattern on the wall behind them, as if it went through both slits at once.
In the single-photon version of OMEGA, you fire one photon into the federation. That one photon is, simultaneously, every guess for the factors. The chambers nudge each branch of it the same way they would nudge a wave. The branches that correspond to wrong guesses run into each other and cancel. The branches that correspond to the right answer survive and reinforce.
Then you put a detector at the exit. The photon has to pick one spot to land. It almost always lands where the surviving branches piled up, which is the spot that corresponds to the correct factors. You repeat the experiment a handful of times to be sure, and you have your answer.
The everyday version of OMEGA uses bright laser light, which behaves like a smooth wave and is easier to build. The single-photon version uses the same chambers but is much gentler: it needs almost no energy, it cannot be eavesdropped on without being noticed, and it is the version that connects this machine to quantum computing in the usual sense. The maths inside the chambers is identical. Only the messenger changes.
A rough analogy: imagine asking a thousand people a yes-or-no question and waiting for the room to go quiet on one answer. The bright-light version is the whole crowd shouting at once. The single-photon version is one person whispering every possible answer simultaneously, and the room itself causing all but the right whisper to fall silent. More on what the chambers measure.
§3 · Worked simulation, N = 391
End-to-end run of the federation { C₁, C₂, C₃ } on a small composite.
A reduced instance chosen so every numerical column is reproducible by hand. The seven steps execute the protocol: enumerate candidates, broadcast to chambers, evaluate each collar, combine on the bulk lattice, threshold, and verify exactly. Step through manually or let it advance.
N = 391 = 17 × 23 (unknown to the chambers)
candidates = 9 · τ = 0.55
step 1 / 7
hostC₁ torusC₂ echosahedron / verifyC₃ mixer
step 00
Write down the number and list the candidates
We want the two whole numbers that multiply to give N = 391. If a factor p exists it sits at most √391 ≈ 19.77, otherwise its partner q = N/p would be smaller and would have surfaced first.
The host writes down every odd p from 3 to 19 and, for each, the candidate partner q = round(N/p). That gives 9 pairs. One of them is the true factorisation. The other 8 are decoys.
N = 391
τ = 0.55
|candidates| = 9
| p | q | p·q | C₁ torus | C₂ echo | C₃ mixer | bulk | verdict |
|---|---|---|---|---|---|---|---|
| 3 | 130 | 390 | — | — | — | — | — |
| 5 | 78 | 390 | — | — | — | — | — |
| 7 | 56 | 392 | — | — | — | — | — |
| 9 | 43 | 387 | — | — | — | — | — |
| 11 | 36 | 396 | — | — | — | — | — |
| 13 | 30 | 390 | — | — | — | — | — |
| 15 | 26 | 390 | — | — | — | — | — |
| 17 | 23 | 391 | — | — | — | — | — |
| 19 | 21 | 399 | — | — | — | — | — |
§3b · Survivor sets per chamber at threshold τ = 0.55
What each chamber alone would accept, and why their intersection is unique.
A single chamber is not enough. Applying the same threshold to each chamber's score individually gives three different survivor sets, each containing the true factor plus false positives that chamber happens to be blind to. The federation works because the three "blindnesses" are uncorrelated: the intersection collapses to one pair.
C₁ torus (low-bit)1 / 9
| (p, q) | p·q | score |
|---|---|---|
| (17, 23) ✓ | 391 | 1.00 |
Single survivor at this scale, by virtue of the small toy.
C₂ echo (balance)8 / 9
| (p, q) | p·q | score |
|---|---|---|
| (19, 21) | 399 ≠ 391 | 0.98 |
| (17, 23) ✓ | 391 | 0.96 |
| (15, 26) | 390 ≠ 391 | 0.92 |
| (13, 30) | 390 ≠ 391 | 0.88 |
| (11, 36) | 396 ≠ 391 | 0.82 |
| (9, 43) | 387 ≠ 391 | 0.77 |
| (7, 56) | 392 ≠ 391 | 0.70 |
| (5, 78) | 390 ≠ 391 | 0.60 |
Includes 7 false positives this chamber cannot rule out.
C₃ mixer (residues)1 / 9
| (p, q) | p·q | score |
|---|---|---|
| (17, 23) ✓ | 391 | 1.00 |
Single survivor at this scale, by virtue of the small toy.
Set algebra at τ = 0.55
C₁ ∩ C₂ = (17,23)
C₁ ∩ C₃ = (17,23)
C₂ ∩ C₃ = (17,23)
C₁ ∩ C₂ ∩ C₃ = (17,23)
For this toy N = 391 the three-way intersection contains (17, 23). The verifier accepts it because 17 × 23 = 391. At cryptographic scale the per-chamber survivor sets remain large (hundreds to thousands of pairs each); the intersection shrinks fast because the three checks fail independently on off-factor candidates. The optical interference picture in §2b is the soft, continuous version of this set-intersection.
§4 · Chamber families in the libraryThe three chamber geometries used
The three chamber geometries used
across every architecture.
Each chamber is a finite OPH observer with its own boundary ports, its own collar repertoire, and its own kind of bias. The federation depends on mixing geometries; no single shape resolves the answer on its own.
symmetry · reference
Echosahedron
Faceted icosahedral observer with 12 vertex ports. The clean symmetry reference body. Its readouts are interpretable, though on its own it retains noisy neighbors.
constraint · discrimination
Asymmetric Mixer
Three-arm skewed plate that deliberately breaks redundancy. Generic residue and mode constraints produce more distinguishable readouts here than on a symmetric body.
§5 · Federation topology
How the chambers, host, lattice and verifier are wired.
A federation is a fixed spatial arrangement of chamber bodies around a shared candidate lattice. The host beam encodes N and distributes the candidate set; each body samples the lattice and writes its scores back; the target verifier reads only the lattice's brightest surviving pair. Switch architectures to see how the wiring changes.
Torus
3
Echosahedron
1
Asym. Mixer
1
Layout
Planned five-element contractor build: two general torus bodies, one search torus, one Echosahedron, one asymmetric mixer.
§6 · Phasor sum per candidate
Coherent vs. incoherent addition of collar contributions.
Each observer collar contributes a complex amplitude (a phasor) for every candidate pair. When the phasors align, the vector sum is large and the candidate's intensity is high. When they scatter, the vector sum collapses toward zero. The plot below shows the phasor set and its sum for one candidate.
selected candidate
(941, 971)
N = 913711 · bits = 20
intensity
1.000
collars
4
true
cycle architecture
legend
● matched collar. Locked phase, coherent contribution.
● mismatched collar. Rotating phase, averages toward zero.
● resultant. The candidate's declared intensity.
§7 · Bulk candidate lattice
Candidate intensity distribution under threshold sweep.
Each candidate pair sits at (p/√N, q/√N). Its height and color encode the consensus intensity it earns from the federation. The threshold sweep dims rejected candidates and exposes the bright ridge of survivors, with the single accepted pair on top.
arch · omega-i1-fiveN = 11323967bits = 24threshold = 0.72true · (2939, 3853)
Bulk intensity histogram
5,000 candidates
I = 0threshold = 0.72I = 1
§8 · Pairwise observer agreement
Jaccard overlap of retained candidate sets across chambers.
A single chamber retains hundreds of candidates. Pairwise Jaccard overlap (the fraction of candidates both chambers keep) collapses when the bodies disagree. Bright cells below mark two chambers agreeing on a small, shared survivor set that includes the true pair.
| ech-01 | mix-01 | torus-01 | torus-02 | torus-03 | |
|---|---|---|---|---|---|
| ech-01 | 1.00 | 0.00 | 0.01 | 0.02 | 0.04 |
| mix-01 | 0.00 | 1.00 | 0.01 | 0.01 | 0.01 |
| torus-01 | 0.01 | 0.01 | 1.00 | 0.01 | 0.03 |
| torus-02 | 0.02 | 0.01 | 0.01 | 1.00 | 0.01 |
| torus-03 | 0.04 | 0.01 | 0.03 | 0.01 | 1.00 |
observers
5
bodies in the federation
pair overlaps
10
distinct chamber pairs evaluated
true-in-intersection
10 / 10
pairs where the true (p,q) survives both retained sets
A single Echosahedron keeps the true pair, but also a few hundred neighbors. Mixed federations collapse the toy universe to the true pair on this modeled pass. This is the visual story of why mixed bodies matter.
§9 · Classical verification boundary
Exact integer multiplication is the final acceptance test.
The optical layer narrows the candidate distribution; it does not commit to an answer. A pair (p, q) is accepted only when ordinary integer arithmetic confirms p · q = N. Everything above this boundary is approximate; everything below it is exact.
accepted
2939×3853=11,323,967
run_id
omega-i1-five|bits…seed=2400515
architecture
omega-i1-five
bits
24
candidates
5,000
Scaling note · what changes for cryptographic N
The toy in §3 uses N = 391 and 9 odd candidates so the table fits on screen. For a 2048-bit RSA modulus the unconstrained candidate count is ~2^1023, far beyond enumeration. The collars (low-bit residue, sqrt-symmetry, small-prime residue) carry over unchanged. What changes is how candidates are proposed: instead of enumeration the host samples structured candidate distributions (sieve-derived strata, Coppersmith windows, and so on) and the bulk lattice retains a budget of the brightest. The verifier boundary above is the same. The only thing that counts as an answer is a pair (p, q) with p · q == N in exact integer arithmetic.
The chosen run on the left is drawn from the bundled dataset (architecture omega-i1-five, 24-bit composite, 5,000 candidates evaluated). The number above is the verifier's accepted pair for that run.
§9 · embodied OMEGA versus a transformer in a data centre
The same chambers that cancel wrong factor guesses can carry the state of a small, always-on agent. The cost profile looks nothing like a hosted LLM.
A transformer language model is a very large pile of fixed weights that is reloaded into memory for every request, fed a fresh context window each time, and run forward in a long sequence of matrix multiplications on a rack of GPUs. An embodied OMEGA agent is the opposite shape. It is a single recurrent observer that keeps its own state in a small binary blob, updates that blob when the chambers settle, and never has to be reloaded, retokenised or rerun from scratch.
Transformer in a data centre
A frontier model is on the order of 10^11 to 10^12 parameters, each stored at one or two bytes. To answer a single query the host has to stream those weights through GPU memory, hold a context window of tens of thousands of tokens, and run a quadratic attention pass over it. Every new turn re-reads the full history. Every new user starts a fresh process. The model itself has no memory between sessions, so the context window is doing the work of state, repeatedly, in software.
The energy cost is dominated by moving weights and keys and values across the memory hierarchy. A medium-length chat response is in the rough neighbourhood of one to ten watt-hours at the wall, scaling with both model size and context length. The model lives in a rack. The user talks to it through the network.
Embodied OMEGA observer
An OMEGA agent does not store a separate set of weights and a separate context. Its state is one small binary blob, on the order of kilobytes to a few megabytes, that encodes the current phase pattern the chambers have settled into. New input is fed in as a perturbation of that pattern. The chambers run one transit, the blob updates, and that updated blob is the agent's entire memory of what just happened. There is no separate KV cache, no context window to refill, no weight matrix to stream.
Because the update is one optical pass, the energy per step is the energy of one laser pulse plus the few microjoules of electronics around it. The agent runs locally, on the device, indefinitely. It does not need a network round-trip, a tenant slot in a data centre, or a context window that has to be rebuilt every turn.
energy per inference step
~10^6 ×
One optical transit plus low-power electronics, versus a full forward pass through 10^11–10^12 transformer weights on a GPU. Roughly six orders of magnitude less joules per step at the wall.
memory footprint of state
~10^6–10^9 ×
A kilobyte-to-megabyte phase blob, versus hundreds of gigabytes of weights plus a context window measured in megabytes that has to be rebuilt every turn.
latency per turn
~10^3–10^5 ×
A chamber transit completes in hundreds of picoseconds. A hosted LLM turn is dominated by network plus tens to hundreds of milliseconds of GPU time.
where the numbers come from
The transformer side of the comparison uses public figures for frontier dense and mixture-of-experts models running on H100-class accelerators, with KV-cache and attention costs scaled to a typical multi-turn chat. The OMEGA side uses the same energy accounting the rest of this page uses: one laser pulse for the chamber pass, plus the analogue-to-digital and control electronics needed to read the blob out and write the next input in.
The overall efficiency gain for a continuous, on-device agent is estimated at roughly six orders of magnitude in energy per interaction, with another two to three orders of magnitude when the comparison includes the data-centre overhead the hosted model carries (cooling, redundancy, networking, tenant isolation) that an embodied observer does not pay for. As with the factorisation numbers in the abstract, these are upper-bound estimates from the model on this page. Embodied OMEGA hardware is work in progress.