Integrate-and-Fire
With Lag
I added lag to the situation in such a way that every processor has the same amount of lag, tau, and this was small compared to the period (usually about 1% of the period). Since I did not use timestamps, it doesn't matter whether we call this process or transmission lag.
Normalizing Inputs
One thing to note is that in any network where different nodes have different numbers of neighbors, synchrony is no longer a fixed cycle of the system. Without lag, when a system is synchronized, everyone spikes and hears spikes at exactly the same time. Recall that when a node is spiking, it does not respond to anything, so the system is in a fixed cycle. With lag, everyone spikes at the same time, but they all hear it at a time L later, and so they actually respond. If the number of neighbors are different, then different nodes respond in different amounts and system becomes desynchronized. The easiest fix to this is to normalize the inputs. That is, have everyone divide the strengths assigned to the incoming spikes by the number of neighbors. Unfortunately, this assumes knowledge of number of neighbors, which may not be accurate under fewer assumptions (though shouldn't be too off for more than one period).
Just Add Lag
Without normalizing inputs, we see the following interesting behavior on a line or ring:
The scale on the time axis in the above image is much smaller than in other spike trains so that you can see the fine detail of the limit cycle. As you can see, the line has split into distinct regions, each of which is split into two sub-regions. The sub-regions are exactly tau apart: I call the first the trigger sub-region and the second the follower sub-region. The two nodes bounding any region will always be part of the follower sub-region.
I have done some analysis to show that limit cycles of this type are indeed fixed cycles, and am currently working on showing that they are stable to small perturbations. The method of analysis was adapted from Ernst, Pawelzik, and Geisel (1998). Although it is clear (again, from extensive simulations, with this more than the others) that this type of behavior is almost always the end result regardless of initial conditions, it is very difficult to prove that a type of behavior, rather than a particular limit cycle, is stable. Particularly when a perturbation from one limit cycle may take the system into another limit cycle which still follows the same behavior.
The other interesting characteristic the analysis revealed was the length of time allowed between any two regions. It is a limited range, and given a lag time can be made more limited by adjusting the coupling strength (to a certain degree). If we are allowed freedom to control both the lag time and the coupling strength, we can get it so that regions may only be very close to exactly half a period apart from one another. While this is not synchrony, having noisily-synchronized regions exactly half-periods apart from one another may be useful behavior. Analagous behavior occurs on a two-dimensional lattice, though it is more complicated (not only is there a checkerboard of trigger and follower nodes, but the borders of two regions can also interlock to form triggers and followers). If you are curious about the detailed analysis, you may ask me directly or wait until I publish it either here or elsewhere (when it is more complete).
Refractory Period
A refractory period is a short time (relative to the period) after spiking in which the "neuron" is resetting its potential. For us, since we can effectively reset a processor's state to 0 instantly, this means a period in which the processor doesn't pay attention to any spikes it hears. This is often introduced to prevent tetany (a state of rapid firing brought about in situations where the lag is not small compared to the period or the coupling strength is large). When we include lag and a refractory period twice the lag time, on a line we get the following wave-like structure:
The upward-moving kink in the wave is simply the system on its way to its limit cycle. The last two waves show the stable limit cycle. What we have here is alpha-synchronization, where alpha in this case is just the lag time, tau: no two neighbors fire more than tau apart, and the entire network fires within d*tau, where d is the diameter of the network (in this case the length of the line). Again, based on a large number of simulations, this type of limit cycle appears to be the final state of the system for almost all initial conditions. An analagous limit cycle occurs on a two-dimensional lattice. (Similar behavior obviously results if we run the simulation on a ring, or a grid on a torus.)