Arshad's Transpose
Circular Linear Algebra on Z₂₅₆

Transpose as Orientation + Recoverability

Arshad's Transpose is the MPRC proposal for replacing a flat row/column transpose with an operation that preserves circular state, orientation, recoverability, and ring distance. The unit domain remains Z₂₅₆ with origin/singularity at 128, but learning and descent do not take place inside a single 0–255 unit. They take place over the Hilbert carrier HV×N, where the current visual carrier has HV=14,464 states per sample or layer context.

The missing second component is the Accumulation-Differential Identity (ADI): the state is not represented only by a target and a local ring step. Its path structure is captured by an accumulation Λ and a first differential δ₁, from which the remaining coordinate differentials are deterministically generated. This exact recovery structure is what makes the later Identity-2 trace and inverse-recoverability results meaningful.

One Unit Is 0…255

The basic state unit is one unsigned byte on the ring:

The interpretation is geometric: distance from 128 and direction around the ring replace an ordinary signed scalar axis. No float or signed-number representation is required for the core state.

Matrix Tᵀ Forgets Circular Orientation

A conventional transpose exchanges row and column indices. For an MPRC tensor this is insufficient because the entries also carry ordered ring position and orientation. The transpose therefore has to preserve or explicitly invert the traversal relation; otherwise two tensors with identical rectangular layouts but opposite circular orientation become indistinguishable.

The Missing Right Component

For a sequential N-dimensional state (a₁,…,a_N), ADI uses two observables:

The remaining differentials are not free variables. Under the odd-increment rule:

For δ₁=11 this gives 11,14,19,26,35,… . This is the component omitted from the previous draft: ADI is not merely the final stride-inverse closure. It is the accumulation-plus-differential structure that describes the N-dimensional path itself.

Two Observables Recover the Whole Path

Given Λ, δ₁, and the odd-increment rule, the coordinate vector is recovered exactly:

The derivation is direct: substituting a_{k+1}=a₁−δ_k into Λ=Σaᵢ gives Λ=Na₁−Σδ_k. The uploaded ADI paper reports 400,500 random reconstruction trials from N=2 through N=256 with zero errors within the stated odd-increment domain.

Why Λ and δ₁ Are Both Required

Within the ADI path family, Λ fixes total accumulation and δ₁ fixes the opening differential. Without Λ the scale is undetermined; without δ₁ the differential staircase cannot be generated. No third independent observable is required because every δ_k for k≥2 follows deterministically from δ₁.

Recovery on Z₂₅₆

For a_i∈Z₂₅₆ the paper defines:

For N=2^k, the proposed ring-native implementation uses a right shift for division by N; for odd N, a modular inverse exists whenever gcd(N,256)=1. The scope remains the specific sequential-navigation/odd-increment family stated in the ADI paper, not arbitrary-vector compression.

Descent Lives in HV × N

For the current vision carrier:

The earlier ADI implementation exposed the important failure mode: navigating descent only over 0–255 confuses the deterministic state alphabet with the computational search space. A byte state already knows how to wrap on Z₂₅₆. What has to be learned is where the interacting state lies across the Hilbert carrier and across N samples, sites, channels, or model states.

Do Not Descend Inside the Alphabet

BIND · REACT · MEASURE

The learning route uses the GEVHV operator family rather than importing a conventional gradient scale into the ring:

ADI does not invent the target. MEASURE defines the target relation; ADI supplies the recoverable path geometry and the STEP used to reach it.

The Target Comes from the Measure

Once MEASURE has produced t, the descent begins from a seed μ₀ and advances by ADI steps:

No Teleport to the Target

The early solve_byte() prototype contained an invalid escape: if no trial stride improved the measure, it assigned current = target. That proves assignment, not descent. The corrected closure uses the exact inverse of stride 7:

This is the local ring closure. It must not be mistaken for the complete HV×N descent or for the ADI recovery identity above.

Recoverability Extends to Streaming Evolution

The corrected Identity-2 evaluation tests the ring-native engine as an evolving trace rather than as a single snapshot. Across the supplied test horizons, both the initial payload and terminal payload roundtrip exactly in single-thread and twenty-thread runs; the companion comparison also reports exact FFT/IFFT reconstruction in those tests.

Wave-Native Streaming Cost

For localized wave-analysis workloads, the supplied comparison reports Identity-2 trace generation far below STFT/WFT latency and memory in the tested implementation. In the single-thread measurements, trace generation grows from 4.500 μs at length 256 to 306.400 μs at length 16,384, while STFT spans 795.600–51,651.200 μs and WFT 792.300–52,480.500 μs over the same lengths.

The twenty-thread advantage ratio is intentionally not presented as a new ADI capability: the source notes that FFTW thread-launch overhead regresses the comparison kernel at these small sizes. Raw FFT snapshot latency can still be lower than the current Identity-2 encode path at larger dimensions. The defensible claim is exact inverse recoverability plus wave-native streaming efficiency, not universal dominance over every FFT workload.

STEP Instead of Derivative Scale

Conventional gradient descent requires a derivative direction and a chosen scale such as a learning rate. The MPRC route separates the problem:

This three-part separation is the right form of the descent: representation, target selection, then movement.

From Rectangular Products to Circular Composition

Arshad's Transpose is being developed as part of the broader MPRC kernel route intended to replace or reduce dependence on GEMM, GEMV, IMMA, and conventional gradient descent. The replacement is not claimed merely by renaming matrix multiplication. It requires composition, activation, recoverable path encoding, target selection, and update to be expressed through ring-native operations and then benchmarked against standard kernels.

Transpose Must Preserve CW/CCW

A valid circular transpose needs an involution test while preserving ring distance and orientation semantics:

The exact kernel law implementing that involution remains active proof/implementation work.

Fixed vs Open