VRC — Volumetric Recurrent Computing
Volumetric Recurrent Computing (VRC) is a proposed computing architecture in which a transient physical state repeatedly evolves through the same configurable, nonlinear, three-dimensional physical medium.
Its defining abstraction is
[ S_{t+1}=F_{\Theta}(S_t,Q), ]
where:
- (Q) is the problem or persistent external input;
- (S_t) is the transient computational state at iteration (t);
- (\Theta) is the comparatively slow-changing configuration of the physical medium;
- (F_\Theta) is the transformation produced by the medium’s actual physical dynamics.
The defining feature is recurrence:
[ S_0 \xrightarrow{F_\Theta} S_1 \xrightarrow{F_\Theta} S_2 \xrightarrow{F_\Theta} \cdots \xrightarrow{F_\Theta} S_T. ]
The physical operator (F_\Theta) remains the same. Computational depth is obtained by allowing the state to traverse or evolve through it repeatedly.
Why this differs from conventional machine learning hardware
Modern neural networks are usually represented as numerical parameters stored in digital memory. During inference, processors repeatedly move those parameters and activations between memory and arithmetic units and numerically evaluate operations such as matrix multiplication, normalization, nonlinear activation, attention, and state updates.
Schematically,
[ \text{stored parameters} \rightarrow \text{memory movement} \rightarrow \text{arithmetic} \rightarrow \text{new numerical state}. ]
VRC asks whether a useful class of learned transformations can instead be embodied directly in matter.
In a photonic realization, for example, the transient state might be an optical field, while the learned operator could be represented by a three-dimensional distribution of refractive index, coupling, loss, gain, nonlinear response, resonant structure, or programmable optical states.
Then the corresponding operation becomes closer to
[ \text{optical state} \rightarrow \text{configured physical medium} \rightarrow \text{new optical state}. ]
The medium does not retrieve a numerical description of the transformation and then calculate it. Its physical response is the transformation.
Why this differs from conventional photonic acceleration
Much photonic machine-learning hardware begins with an operation already important to digital neural networks—particularly matrix multiplication—and seeks a faster or more energy-efficient optical implementation.
VRC starts from the opposite direction.
It asks:
What machine-learning architecture naturally follows from the computational primitives of programmable nonlinear three-dimensional photonic matter?
The answer need not reproduce a Transformer, GPU tensor core, or conventional feed-forward neural network.
A photonic VRC substrate might naturally provide:
- complex-valued amplitude and phase;
- three-dimensional local connectivity;
- interference and diffraction;
- wavelength, polarization, and spatial multiplexing;
- nonlinear material responses;
- resonant or delayed state;
- configurable routing and coupling;
- massive spatial parallelism;
- physical recurrence.
The learning architecture should therefore be designed around those primitives rather than requiring the substrate to emulate operations inherited from digital computers.
Three physical timescales
A useful VRC implementation can be described by three layers of state:
[
\boxed{
\begin{array}{lll}
G &:& \text{physical topology}
\Theta &:& \text{learned configuration}
S_t &:& \text{transient computational state}
\end{array}}
]
(G): topology
(G) determines what can physically interact with what.
In a photonic implementation this might consist of three-dimensional waveguides, scattering structures, cavities, defect paths, or other connectivity fabricated by methods such as femtosecond-laser writing.
It changes rarely.
(\Theta): configuration
(\Theta) determines the current computational behavior of that physical topology.
Examples include programmable phase shifts, coupling strengths, nonlinear thresholds, persistent optical states, or other locally configurable material properties.
Training primarily changes (\Theta).
(S_t): transient state
(S_t) is the state undergoing computation.
For photonics it could be a spatially distributed complex optical field,
[ S_t(x,y,\ldots)=A_t e^{i\phi_t}, ]
possibly also using wavelength, polarization, temporal modes, or other optical degrees of freedom.
Inference primarily changes (S_t).
Thus:
[ \text{fabrication changes }G, ]
[ \text{learning changes }\Theta, ]
[ \text{reasoning changes }S_t. ]
The central VRC conjecture
VRC becomes architecturally interesting only if recurrence provides something stronger than repeated filtering.
Its central conjecture is:
A fixed configurable nonlinear physical operator with a fixed-size transient state can obtain greater effective problem-solving depth by evolving for longer.
Formally, hold
[ F_\Theta ]
and
[ \dim(S) ]
fixed while increasing recurrence time (T).
The conjecture predicts that, for suitable tasks,
[ T\uparrow \quad\Longrightarrow\quad \text{effective computational or reasoning depth}\uparrow. ]
A harder problem could therefore consume more time without requiring a larger physical machine, a larger parameter set, or a larger transient state.
This is the principal property that distinguishes VRC from merely implementing a neural-network layer in optics.
A possible photonic realization
One concrete implementation would use a programmable three-dimensional nonlinear photonic fabric.
Its local dynamics might be abstracted as
[ z_i(t+1)
\sigma_{\theta_i} \left( \sum_{j\in N(i)} J_{ij}(\Theta)z_j(t) + B_iQ \right), ]
where:
- (z_i) is the optical state near physical location (i);
- (N(i)) contains physically connected neighboring regions;
- (J_{ij}) represents configurable optical coupling;
- (\sigma_{\theta_i}) represents a local nonlinear optical response.
The full volume collectively implements
[ S_{t+1}=F_\Theta(S_t,Q). ]
The output state is then recirculated through the same medium.
VRC does not require this particular discretization. In a more general realization, (F_\Theta) could be a continuous physical dynamical system defined by trainable distributions such as
[ n(x,y,z),\qquad \chi(x,y,z),\qquad g(x,y,z), ]
rather than an explicit lattice of nodes and wires.
What VRC does not assume
VRC does not inherently require:
- Transformers;
- attention;
- matrix multiplication as the fundamental primitive;
- digital weights;
- a layer-by-layer architecture;
- optical-to-electrical conversion between recurrences;
- quantum computation;
- a particular material;
- a cubic geometry;
- a particular training algorithm.
Those are implementation choices or hypotheses to be tested.
The defining requirement is narrower:
[ \boxed{ \text{configurable volumetric nonlinear dynamics} + \text{transient state} + \text{recurrence}. } ]
Research question
The immediate research question is therefore not whether photonics can accelerate an existing neural network.
It is:
Given programmable nonlinear three-dimensional physical matter, what computational architecture should be trained to inhabit it?
VRC proposes one answer: treat the physical medium as a reusable learned dynamical operator, treat the evolving physical field as computational state, and obtain additional computational depth by recurrent evolution through the same configured matter.
The proposal is falsifiable. If increasing recurrence with fixed operator and fixed state size fails to produce systematically greater effective computation on increasingly compositional tasks, then the central architectural motivation for VRC is weakened.
If it succeeds, the result would suggest a computing regime fundamentally different from both conventional digital neural networks and photonic accelerators designed primarily to emulate them.