MONOLYTH is an experimental reversible-computation project.
The current architecture contains four independently reversible systems:
MONOLYTH
BIREALITY ENGINE
RHAPSODY OF ABSURDITY
NEMESIS
Each system supports forward execution and an exact inverse.
The systems had previously been validated independently and as a reversible cascade on CPU.
The experiment reported here asks a narrower question:
Can the complete four-system object execute on CUDA, reproduce an independently generated CPU forward state exactly, and then recover the original complete state exactly through the inverse trajectory?
The answer for the tested implementation is yes.
Common carrier
All four systems operate through a common:
5,456-bit carrier
682 bytes
The active interpretation differs between systems.
MONOLYTH
496 × 4-bit cells
1,984 active bits
248 active bytes
The remaining carrier tail is preserved.
BIREALITY ENGINE
496 × 10-bit cells
4,960 active bits
620 active bytes
RHAPSODY OF ABSURDITY
496 × 11-bit cells
5,456 active bits
682 active bytes
One structural property of the path is therefore:
496 positions × 4 bits
↓
496 positions × 10 bits
↓
496 positions × 11 bits
The number of positions remains fixed at 496 while the active representation changes width.
NEMESIS introduces another computational scale
NEMESIS operates on a native 1,984-bit active region inside the same 5,456-bit carrier.
That active state is divided into:
A = 1,024 bits
B = 960 bits
Region A is preserved.
A deterministic function of A generates the reversible mask applied to B.
Generation of that mask invokes the WIDTH65536 Gravity structure:
2,097,152 bits
262,144 bytes
256 KiB
of internal field scale.
This does not mean that the carrier itself expands to 2,097,152 bits.
The larger field is a temporary internal computational excursion used by the NEMESIS boundary operation.
Four-system Diamond
The CUDA experiment uses four carriers simultaneously:
4 × 5,456 bits
21,824 bits
2,728 bytes
This four-carrier structure is referred to as the Diamond.
For one clockwise microstep:
North : MONOLYTH
East : BIREALITY ENGINE
South : RHAPSODY OF ABSURDITY
West : NEMESIS
After the four operators execute, the carriers rotate clockwise.
After four microsteps, every carrier has visited every operator exactly once.
A carrier beginning at the Monolyth side therefore experiences:
MONOLYTH
→ BIREALITY ENGINE
→ RHAPSODY OF ABSURDITY
→ NEMESIS
The other carriers begin at different points of the same four-system cycle.
First CUDA mapping
The initial CUDA implementation was deliberately simple:
1 CUDA block / Diamond
256 threads / block
The large Gravity working state was placed in explicit global workspace and processed cooperatively by the CUDA block.
No mathematical simplification was introduced.
No larger stage was replaced with a CUDA-friendly approximation.
No performance optimization was applied before the first correctness test.
Successful sm_61 compilation on an NVIDIA GTX 1050 produced:
registers = 121
stack frame = 120 bytes/thread
spill stores = 0
spill loads = 0
shared memory = 2,348 bytes/block
threads/block = 256
Independent CPU authority
Before CUDA execution, an independent deterministic CPU forward authority was generated.
DIAMOND_BITS=21824
DIAMOND_BYTES=2728
CPU_FORWARD_CHANGED_BYTES=2717
CPU_FINAL_BYTE_MISMATCHES=0
CPU_RECOVERY=EXACT
The CUDA implementation therefore had to satisfy two separate conditions:
CUDA forward state
CPU forward authority
and:
CUDA inverse recovery
original Diamond
This prevents a matching forward/inverse implementation error from appearing correct merely because it reverses itself.
CUDA result
The first complete CUDA execution produced:
X1_CUDA_BLOCKS=1
X1_CUDA_THREADS_PER_BLOCK=256
X1_CUDA_FORWARD_CHANGED_BYTES=2717
X1_CUDA_FORWARD_VS_CPU_BYTE_MISMATCHES=0
X1_CUDA_FINAL_BYTE_MISMATCHES=0
X1_CUDA_FORWARD_EQ_CPU=TRUE
X1_CUDA_RECOVERY=EXACT
First unoptimized kernel timing:
446.625793 ms
No performance claim is attached to this timing.
Several regions remain deliberately unoptimized, and only one Diamond was executed.
The timing is therefore treated only as the historical baseline for the first complete CUDA implementation.
The significant result is correctness.
Forward comparison:
CPU forward state
CUDA forward state
byte mismatches = 0
Final inverse comparison:
original Diamond
recovered CUDA Diamond
byte mismatches = 0
The complete:
21,824-bit
four-carrier
four-system
reversible Diamond
therefore executed through CUDA, traversed all four reversible systems, reproduced the independent CPU forward authority exactly, and recovered the original Diamond exactly.
Claim boundary
No claim is made that reversible composition itself is new.
Composition of reversible functions is established mathematics and established reversible-computation practice.
No claim is made that this first CUDA mapping is optimal.
The experimentally established result is narrower:
four independently reversible systems
different active representations
common 5,456-bit carrier
four-carrier 21,824-bit Diamond
multi-megabit internal Gravity excursion
CUDA forward execution
independent CPU/CUDA forward agreement
exact complete inverse recovery
were demonstrated together in this implementation.
No priority claim is made regarding this particular combination.
No close precedent with the same combination of properties has currently been identified.
Comparable references would be relevant.
The experiment is reproducible.
The deterministic input is preserved.
The CPU forward authority is preserved.
The CUDA implementation is preserved.
The executable and corresponding hashes can be preserved.
The complete run can be repeated.
Next experiment
The ordinary four-system forward composition can be represented schematically as:
M → B → R → N
with the exact inverse:
N⁻¹ → R⁻¹ → B⁻¹ → M⁻¹
However, all four forward operators are themselves bijections.
A different valid composition can therefore be constructed:
N → R → B → M
→
M → B → R → N
This is not an inverse trajectory.
It defines a new mirrored reversible permutation.
Its structural behavior is currently unknown.
Questions include:
Does unexpected cancellation appear?
Does the mirrored structure introduce new regularities?
Does forward/inverse execution become more symmetric or less symmetric?
Does the double NEMESIS/Gravity exposure create measurable structure?
Does CUDA map the mirrored composition differently?
Do new short cycles or correlations appear?
Those questions belong to a separate experiment.
For the current result:
21,824 bits entered.
All four systems operated.
CUDA agreed exactly with CPU.
21,824 bits returned.