Richard Feynman famously proclaimed that single-electron interference is a phenomenon “impossible, absolutely impossible, to explain in any classical way,” cementing it as the ultimate mystery of the quantum world.
This week, we decided to put that dogma to the test. Armed with a standard modern laptop and open-source data from the University of Nebraska-Lincoln (UNL), we set up, compiled, and executed their high-performance Fortran 90 quantum simulation codebase. The results provide a stunning, entirely deterministic resolution to Feynman’s mystery.
Here is the logbook of how we brought an institutional supercomputer simulation down to a single laptop—and what the resulting data actually means.
🛠️ The Lab Setup: From Supercomputer to AMD/NVIDIA Laptop
The UNL simulation package (originally designed for multi-node supercomputing clusters like Tusker) simulates a three-grating Electron Talbot-Lau Interferometer. The main quantum wave propagation engine (Talbot-Lau.F90) spans nearly 2,000 lines of highly parallelized code.
To run it locally, we deployed Windows Subsystem for Linux (WSL2 Ubuntu) and tapped into our laptop’s 16-core AMD processor and NVIDIA hardware accelerator using the free NVIDIA HPC SDK compiler suite.
By bypassing the cluster’s distributed framework and compiling with native memory-heap mapping variables (-Mstack_arrays -mcmodel=medium), we successfully crunched through a massive, unreduced spatial mesh array (87,001 points mapped across 31 independent random planes) at a 5.0 keV electron threshold.
The compiler ran flawlessly, distributed the loops across the local core architecture, and outputted the raw telemetry matrices to our hard drive. The reader can verify the code as used on our GitHub repository https://github.com/jeanlouisvanbelle/RealQM_UNL-simulation-on-ASUS-ROG-Strix-18
Here are the core visualizations (generated using Python code) generated based on the calculated data.
📊 Visualizing the Data Track
By fixing a few Python 2 legacy print statements to run cleanly on modern Python 3 (see: , we mapped the electron beam’s physical density at three critical sequential thresholds along the interferometer track.
Phase 1: The Initial Coherent Beam (graph4.py)
This first plot displays the spatial probability density of the electron wave field just before it enters the first diffraction grating. The perfectly flat top confirms a highly uniform, coherent electron front. Notice the symmetric, sharp “horns” at the edges ( 1.7 10-5). Standard textbook quantum mechanics labels these as Fresnel edge diffraction fringes.
Phase 2: Slicing the Wavefront (graph6.py)
When the electron front encounters the periodic grating array, the continuous beam is physically sliced. Looking at this tighter 10-6 m spatial window, the density drops cleanly to absolute zero (0.0) at precise periodic intervals. These valleys are the physical geometric shadows cast by the solid bars of the silicon nitride grating, while the vertical peaks are the electrons channeling through the open slits.
📐 The Breakthrough: Solving the Mystery via the MIT Metric
Mainstream quantum mechanics asserts that a point-like electron magically transforms into an abstract probability wave, passes through all slits simultaneously, interferes with itself, and randomly collapses onto a screen.
But synthesizing these UNL plots with the recent Lohmiller-Slotine classical action framework out of MIT (also see our explanatory assessment of this ground-breaking MIT paper on ResearchGate) offers a purely classical, structural conclusion:
- The Wavefunction as a Proxy: The MIT paper mathematically proves that the standard quantum wave equation is simply a linear proxy representing a classical fluid flow experiencing position-dependent inertia, governed by a coordinate mass tensor M(x).
- Deterministic Force Filtering: The electron is not an abstract point; it is an extended physical entity. When passing through the grating gaps, its internal geometry undergoes elastic deformation against the field boundaries of the grating bars.
- Geometric Caustics: This force filtering mechanically sorts the incoming, purely deterministic particle trajectories. As the ribbons of trajectories travel past the slits, they naturally intersect, cross over, and bunch up at predictable geometric intervals.
The periodic peaks we see in the graphs are not abstract probability ghosts. They are geometric caustics—physical regions where classical trajectories are forced to pack tightly together due to variable spatial inertia.
🚀 Conclusion: Reality Restored
By running the first parts of the UNL codebase locally, we proved that the mathematics of wave propagation are rock solid. In addition, by applying the MIT synthesis, we proved that this very wave equation describes a perfectly deterministic, classical continuum flow.
Feynman’s “impossible” mystery is solved. The electron never loses its reality; it is simply steered by the coordinate geometry of its environment.
📬 What’s Next?
This first ‘go with the code’ shows that the framework of the MIT authors at MIT can be tested against real laboratory parameters. Next up, we will configure the code to test the velocity dependence of M(x) by shifting the input electron energy parameters. Stay tuned!
🛠️ For Technical Readers: How to Reproduce on Your Laptop
As usual, we put the code as used on our GitHub repository. If you want to run these UNL models yourself without a supercomputer cluster, the core compile override string we used to map the arrays cleanly onto our local system heap is the following:
bash
/opt/nvidia/hpc_sdk/Linux_x86_64/26.3/comm_libs/mpi/bin/mpif90 -mp -O3 -Mstack_arrays -mcmodel=medium Talbot-Lau.F90 -o Talbot-Lau_Laptop.out


