We consider this problem now in more general meshes, such as 2D and 3D. Each zone will have a few immediate neighbors and we will not here presume that the mesh is regular. At the outset of a cycle each zone knows its new value only as a constant plus a linear combination of the new values of its immediate neighbors.

We imagine a set of steps towards the solution where in each step some of the zones have eliminated themselves and the remaining zones know their new value as a constant plus a linear combination of the new values of a set of acquaintances among the remaining zones. The acquaintance relation is symmetric and anti-reflexive. I choose metaphorical language here as follows: a zone chooses to eliminate its own value (unknown) by sending a message to each of its current acquaintances a message meaning:

My value will be this here linear combination of these here acquaintances.
Upon receipt of such a message a zone will remove the sender from its own list of acquaintances, and adjust its own linear combination by replacing the sender’s entry with the sent linear combination. This sent combination may well include references to zones with which the receiver was not yet acquainted. These steps will end for the remaining members decreases by one each step.

When all have been eliminated a simple pass visiting the zones in the opposite order of their elimination allows explicit calculation of the new values.

The above speaks as if there were exactly one zone state at each step in the calculation and that zone references were to that current state. This may be a good plan but I don’t want to commit to it yet. That plan indeed comes from the method taught in high school. When we learned this scheme with pencil and paper were indeed working with a write once medium. Now the tables are turned and we seek to think about computing with immutable values upon a machine with mutable memory.

The amount of calculation is sensitive to the order of elimination and I claim that this metaphor ties the mesh topology to the algebra problem so as to guide the intuition concerning the order of elimination.

The metaphor suggests concurrency which may be feasible. The messages must identify zones. I will use small integers here to do this as they have an efficient equality test and are ordered which facilitates discovering old acquaintances that are mentioned in newly received messages. I see no need yet for relating these zone IDs with the topology.

The first version of code, in Scheme, will denote a linear combination (LC) as (cons C (list (zID1 . coeff1) (zID2 . coeff2) (zID3 . coeff3) ...)). These Scheme values are the memory of a zone as well as the payload of a message. The message must include the sender’s ID as well as the LC. The Merge Assimilation routine is useful here. The first versions will not use mutate operators except in a mutable array of current zone states held by the executor. The array is indexed by zone ID. This plan may make the design of the zone code proper not depend on concurrency strategies.

The zone state is a list of procedures: (eliminate yourself, accept elimination message from another)

```(define (create-zone-state ID LC) (list (lambda () (lambda
```