Under the Hood: Building a Physics Simulator Out of Light

In the previous post, we explained how LightSolver’s Laser Processing Unit (LPU) could be used for solving partial differential equations and motivated the split-loop architecture: A single-loop cavity would extinguish itself exactly when it found the solution. Now let us dive into the details of how we implement the split-loop and the operator logic.

The Split-Loop Architecture

The resonator is divided into two paths. The memory loop contains a gain medium and imaging optics that map the optical field onto itself after each round trip. Above a threshold pump power, the gain compensates for cavity losses, and the laser oscillates. These dynamics act on the field amplitude and drive it toward a stable value. The phase of the field, however, remains completely unconstrained by the laser equations. As long as the amplitude stays above threshold, any phase value is equally valid. This loop does not perform any computation. It simply keeps the light alive.

The operator loop does the mathematics on the information that is encoded in the phase of the field. A beam splitter diverts a small fraction of the circulating field into a secondary path containing optical elements that implement the PDE time-step operator. A second beam splitter recombines this processed light with the main beam. The two fields interfere, and that interference nudges the phase of the circulating light forward in time.

The splitting ratio of these beam-splitters determines the step size: Send a larger fraction through the operator loop and the phase evolves faster but less smoothly; send less and convergence slows but becomes more stable. The crucial point is that the phase and amplitude dynamics separate. The memory loop stabilizes the amplitude, while the phase, freed from laser constraints, evolves under whatever mathematical operator is built into the operator path. Since each round trip takes only as long as light needs to traverse the cavity – a few nanoseconds – every iteration runs at constant time, independent of problem size or operator complexity.

Building Operators from Light

The operator loop chains together standard optical components, each performing a specific mathematical task. Beam splitters and fixed optical elements handle the basics: addition and subtraction. These are the same components managing the split between the loops and may be used similarly within the operator path for arithmetic operations.

A Spatial Light Modulator (SLM)is a programmable optical element, containing millions of pixels, where each pixel can independently shift the phase and attenuate the amplitude of light passing through it. Passing through an SLM in the image plane encodes multiplication by a spatially varying pattern.

Even more powerful, however, is passing through the SLM in the Fourier plane. After passing through a lens, the field represents spatial frequencies rather than local values. Multiplying the field by a pattern in this Fourier plane is mathematically equivalent to convolving with a kernel in the image plane. With the right pattern programmed onto the Fourier-plane SLM, we can physically encode convolution operators, which naturally include differentiation operators such as the Laplacian operator that governs diffusion. While performing convolutions on CPUs and even on GPUs is very computationally expensive (i.e. time consuming), in the LPU the time is related only to the length of the cavity, regardless of the kernel complexity.

Enforcing boundary conditions means holding the field (or its spatial derivatives) steady, effectively ignoring the operator, at specific positions (the boundaries). One way of doing this is through a clever trick using a digital micromirror device (DMD). The DMD is used to inject an auxiliary laser beam exclusively at pixels corresponding to the domain boundary. Through carefully designed polarization optics, this injected light is isolated from the naturally evolving field. At boundary locations, the injected beam simply overwrites whatever phase developed through the PDE dynamics. The boundary values are pinned externally, while the interior field evolves freely to satisfy the differential equation.

Iteration at the Speed of Light

Each round trip through the cavity is one iteration, and the phase profile evolves until the operator loop’s contribution vanishes. At that steady state, a camera reads out the phase distribution: the solution to the PDE. In principle, a very fast camera could be used to also measure the evolving dynamics of the PDE solution.

Importantly, the iteration time is set by cavity geometry, not problem parameters. A 100×100 grid and a 1000×1000 grid traverse the same optical path in the same few nanoseconds. The grid size is limited, practically, only by the quality of the optics; the fundamental physical cap then becomes the diffraction limit. Four-neighbor and hundred-neighbor convolutions take the same time per iteration. The computational bottleneck shifts from arithmetic and memory bandwidth to a single question: how many round trips does the physics require?

In future posts, we will examine which PDEs map onto this architecture and where optical solvers fit in the landscape of high-performance computing.