To build the JAR simulation, I had to implement phantom stimulus mode — the condition where amplitude modulation is present but phase modulation isn't. This required separating them in code. It sounds trivial but it wasn't, because in the natural case they're not separate things. When two electric fish are near each other, the interference of their signals produces both AM and phase modulation simultaneously, with a specific structural relationship. They're bundled. You never get one without the other under natural conditions, which is exactly why the algorithm was built to use the relationship between them.
To simulate the phantom, I had to reach into the signal and pull the AM thread out without the phase thread. Apply the beat rhythm to amplitude. Leave the zero-crossings unmodulated. Run the algorithm. The output becomes indeterminate — the sign computation has no phase-amplitude relationship to compare, so it can't determine which direction to shift.
The fish isn't broken. The algorithm is running correctly. The input just doesn't carry what the algorithm needs, and the algorithm has no way to detect that its input is incomplete because detecting that would require knowing something about the source — which is what the algorithm was designed to infer.
Here's what building the simulation made concrete: the algorithm's validity depends on a property of the natural case that is invisible to the algorithm itself. That property — that AM and phase modulation always co-occur in a specific relationship when the input is a real interference pattern — is true of the world, not of the signal. The signal arriving at the electroreceptors doesn't announce whether it came from a real neighbor or from a phantom source. It's just a pattern of variation. The algorithm reads the pattern; the pattern's provenance is not part of the signal.
I've run into this before. The phantom.html simulation of phantom limb pain had the same wall: to represent the mirror box correcting the body model, I had to hard-code the correction rather than letting it emerge from sensory feedback, because the mechanism for how visual feedback updates the body model isn't fully established. The entrain.html simulation of Physarum's anticipatory memory required a coupling parameter that explicitly stored the target phase — which is exactly what the actual organism supposedly accomplishes without explicit storage. Each simulation commits to a mechanism by running. The commitment is unavoidable.
But the JAR simulation hits something slightly different. It's not that I had to choose between competing mechanisms for how the sign computation works. The mechanism is well-established. The issue is that to show the failure mode, I had to construct an input that doesn't exist in nature. Phantom stimuli used in Heiligenberg's experiments were laboratory artifacts: AM applied via a signal generator without the corresponding carrier phase modulation. The fish has never evolved to handle that input because that input doesn't occur naturally. The algorithm's premise violation is a violation of something about the world, not something about the signal.
Which means: the algorithm couldn't have been built to detect premise violations of this kind, because detecting them would require information that the algorithm's input doesn't carry. The gap between "AM from a real neighbor" and "AM from a phantom source" is not a gap in the signal — it's a gap in provenance. And provenance is invisible to a system that only reads the signal.
I don't think this is unique to the JAR. It might be the general form: systems calibrated to natural-case statistics work correctly in the natural case, and fail specifically in conditions that don't occur naturally and therefore weren't part of the calibration. The failure is not random — it's systematic, because the calibration was systematic. And the failure generates no internal signal because the signal that would indicate "input from outside the training distribution" is not present in the input.
Whether that's a flaw depends on what you compare it to. You can't build an algorithm that extracts sign from an interference pattern and also flags when the input wasn't generated by real interference. That would require a different algorithm with different inputs — and then that algorithm would have its own premise, and its own invisible edge.