PART II
Contents of last part (https://psmv4.blogspot.com/2021/03/a-one-dimensional-structure-part-i.html)
Introduction
- Playing with dimensions
- One dimensional views
- Blobs
- Not much data
- References
Contents of this part
- Some processing
- Cellular automata
- Some structure
- Rather more data
- Some examples of moves in one dimension
- Additional information
- Conclusions
- References
Some processing
 |
| Figure 13 |
Following the lead of Figure 11 above, we now activate our simple, one dimensional structure in the hope of making it more interesting. We offer a simple processing structure, sketched in the figure above, looking in some ways rather like the famous Turing machine. Simple in the sense that processing is local and depends only on the current state of an interval and perhaps that of a neighbour. There is no history, there are no global states and no goals to strive for.
Our intervals have two properties, display colour (DC) and display length (DL). Both properties are expressed in the model above as 8 bit bytes.
However, while our world is reasonably continuous in space, it is discrete, it is stepped in time, advancing one short, fixed length step in time at a time.
The environment includes a process called the jiggler. This jiggles the intervals about in such a way that at each step an interval may be inactive, active, looking right or looking left. This jiggling is random.
 |
| Figure 14 |
For each step we will have a possibly empty set of intervals which are candidates for independent action and a possibly empty set of pairs of intervals which are candidates for joint action. Given that an interval cannot face both right and left, any one interval can only be a candidate in at most one way. By way of example, in the figure above, we have two independent candidates and two joint candidates. Marked with blue lines above.
Next, the environment includes a second process called the external executor, which inspects all the intervals every step.
The execution status of every interval starts as inactive.
In the case that an interval is inactive, its execution status is left as inactive.
In the case that a non-null interval is active, its execution status is set to active.
In the case that an interval is looking right and the interval to its immediate right is looking left, there is a choice between setting the execution status of the first interval to looking right or that of the second interval to looking left. A random choice is made. This is as far as action at a distance goes: an interval may interact with one of its next-door neighbours.
Once this process is complete, the intervals do their part. That is to say the active, looking right and looking left intervals execute, this being the job of their internal executors.
Rules are held in the rules table. Each interval carries its own copy of the rules table – rather in the way that each cell of an animal carries its copy of the genes – and it able to execute those rules without needing help from the centre – unlike much computing where most of the computation is done in a central processing unit, rather than out on the periphery, be the computer a chip or something larger.
Each rule is in two parts, a condition and an action. The conditions only have the length and colour of the intervals involved to go on. They probably do not have things like date or time of day as that suggests some central activity. And given the simplicity of our intervals, the repertoire of actions is unlikely to be large.
 |
| Figure 15 |
A sample of conditions.
 |
| Figure 16 |
A sample of actions on objects without a partner.
 |
| Figure 17 |
A sample of action on objects with either a right hand or left hand partner.
At any one step, for any one interval, the conditions for zero, one or more actions may be met. For the moment we suppose that in the case that more than one action is available, a random choice is made. Only one action is executed at any one interval at any one step.
Once all the actions have been completed, control is returned to the external executor which merges any adjacent intervals which have come to have the same colour, adjusting the display length appropriately.
We then have a starting sequence and let the system loose on it, let the system roll. If and when the last interval standing self-destructs to null the system will stop, but we say nothing more about stopping. The system may or may not get into a repeating loop. It may or may not grow beyond the bounds of the space available.
The behaviour of the system is a function of the starting sequence, the rules table and the various probability distributions which qualify the application of those rules – with the number of possibilities being very large.
Nevertheless, this probably does not include programming in the way of a regular computer. One could write a sequence of actions of the sort suggested above to achieve some particular goal, for example to move the left hand terminal interval to the left. But in the absence of system state or memory, it seems unlikely that we can so organise a rules table so that such a sequence was reliably executed.
With the question of interest here being whether such a system exhibits interesting behaviour at all.
The section which follows suggests that we will certainly get complex behaviour – but whether or not that behaviour moves from random and unpredictable to something more interesting is another matter. We suspect to get that, a bit of top-down regulation is required, something which may not be available in our simple, feed-forward world.
Cellular automata
A system of the sort just described is not that far removed from the cellular automata of reference 3 – with the specification of such automata being quite elementary – and the resultant behaviour surprisingly complicated. Indeed this is one of the central puzzles that this book addresses: how is it that such complexity emerges from the application of such simple rules?
Simpler than what has been suggested above, in that every interval in a cellular automaton has the same length and takes one of just two colours, black or white. The rules, however, are quite like our actions, only depending on the subject interval and its two neighbours.
Plus, in the early examples given at least, the starting point is minimally simple, just the one black square.
 |
| Figure 18 |
The actions available in the starting variety of cellular automata are expressed in the eight part rule, eight for the eight combination of left hand neighbour, subject cell, right hand neighbour. Starting at the top and coming down, starting with a single black cell in the middle, we have rows of cells for each successive step in time. The rules tell us how to get down the columns. In this example, for example, if there is nothing to start with, as in the right most part, you get nothing. And if there is everything to start with, as in the left most part, you also get nothing.
Rules which are stronger than our actions in that the next colour of a cell depends on that of both its neighbours, as well as its own colour. Weaker than our actions in that there are just two colours and there is no concept of length. There is no splitting or merging of cells.
The action table of a cellular automaton will be a lot smaller than that suggested for coloured intervals above. By comparison, our intervals have to carry quite a lot of information.
Automata which just roll forward, with the behaviour of cells not being influenced by anything other their own present state and that of its two neighbours. What might have happened in the past, what might be happening across the piece and what might be wanted for the future do not come into it. No adjustments to the rules to take account of these wider considerations.
 |
| Figure 19 |
Which might give us something like the graphic above, where time comes down the page and where each row is the line of cells, each taking the value black or white. Where the missing left hand triangle is not much different from the chunk that has been included. A graphic which includes plenty of features large and small, but which is very different from Figure 9 above.
Wolfram goes on to consider variations on his basic theme, but for present purposes the results are the same, with plenty of complexity arising from simple rules. From where I associate to the hugely difficult problems which arise in number theory, with this last being based on a small number of innocuous looking postulates, perhaps those at reference 4.
So it seems likely that our animated one-dimensional segment will have complex behaviour. But will it have interesting behaviour?
Some structure
Thinking back to the two dimensional structure at Figure 9 above, we now propose some structure which we might put on our one dimensional world of segments. Noting again that this is just one of many ways in which this could be done; the point being to exemplify the rich structures that are possible in one dimension, rather than to privilege any particular structure.
 |
| Figure 20 |
In any one segment, we have three sets of non-null colours. The ones that do not appear at all (C1), the ones that appear just once (C2) and the ones that appear more than once (C3). These last being blue and black in the figure above.
We call the intervals coloured by a colour in C2 the simple objects. So the red interval in the figure above is a simple object. The C2 intervals are mutually disjoint. They may touch, but they may not overlap.
 |
| Figure 21 |
Within a segment, we call the intervals defined by the smallest and largest point coloured by any one colour in C3 the complex objects. A complex object has two terminal intervals and will usually, but not necessarily, have interior intervals. The colour defining the complex object is called its medium, which may or may not appear in the interior as medium intervals. We think of the internal medium of the object is roughly comparable to the cytoplasm of a eukaryotic cell – and will become important when we come to consider movement with a complex object. There are two complex objects in Figure 20 above. Complex objects may both touch, as they do there, and overlap, as they do in the next figure, Figure 21 above. So a basic object may belong to zero, one or more complex objects.
An ambiguity which complicates things if we try to move one complex object through another.
 |
| Figure 22 |
If, for some reason, the right hand black interval in Figure 22 above degrades into the null interval, the right hand complex object shrinks in a rather arbitrary way, suggesting a need for management of such degradation.
Note that, given that we probably have a lot less than 255 non-null colours, the foregoing means that there are low limits on numbers within any one segment. Not more than 255 basic objects and complex objects taken together.
 |
| Figure 23 |
Nevertheless, we can build a rich one-dimensional structure, perhaps something like the segment sketched in the figure above, a bracketed structure which compares, in some respects at least, with the HTML and XML of the Internet with their bracketing tags. But bearing in mind that the one dimensional visualisation does not include the blue brackets, just the line of colours, the human viewer might start to struggle once there are more than half a dozen or so colours.
Furthermore, this structure is in the eye of the beholder. As things stands, the blue interval at the left in Figure 23 above has no knowledge of the closing blue interval, some way to the right. The rules only care about immediate neighbours. To give this structure more substance we might give the centre more authority, move away from our very democratic, decentralised structure. But the alternative we pursue here is giving intervals a bit more data, that is to say more local power rather than more central power.
Rather more data
Rather than interpreting our bytes as colours, we might interpret them as characters. These characters could then be used to write computer programs of more or less arbitrary complexity, programs which could include as much data as we liked. But we would have lost the link to real world geometry: while we could display such a program as a long coloured line, it seems unlikely that there would be anything to see, that the visualisation would add any value. We would have also lost our reasonably plausible link to the sort of processing capability that an organism might possess – although we do associate here to the biological solution, where every cell contains say two copies of the instructions in the form of DNA, very tightly coiled & compressed, but containing such a long of instructions that it might be considered to be an additional dimension. A long sequence of instructions which would not interfere with the organisation of our world into intervals along the real line.
 |
| Figure 24 |
Another solution would be to allow two bytes: one byte for colour and one byte for bracket specification – of which last maybe one bit to say bracket, one bit to say open or closed bracket and 6 bits for the label, giving us something very like the tags of HTML, for example ‘<title> … </title>’. We could build hierarchies of objects, we could have the simple and complex objects introduced about, but we would no longer to tied to colours so to do. We could now have something like the blue and red object in bottom line of the figure above, undisturbed by the repetition of red inside, or the presence of red and blue outside. And for visualisation purposes one might add characters – so open bracket, close bracket and space in the top line.
And then something along the line of the rules introduced above would recognise these brackets, perhaps giving us what amounted to a semi-permeable membrane, allowing a certain amount of traffic in each direction; perhaps different traffics in different directions.
Note that we do not yet constrain our bracketed structures to be trees, to be hierarchies. We still allow the overlap mentioned earlier, which, inter alia, seems to be necessary to support movement across boundaries. We touch on this below.
However, we suggest going the whole hog, and allow 5 bytes of data to the interval. One for display colour (DC); one for display length (DL); one for type, character or code (T); one for state (S); and, one for payload (PL). The processing framework remains much the same as sketched at Figure 13 above, but there is now more data to bite on. Intervals have some history in the form of state and mobile intervals can carry things about in the form of payload.
All of which data would be available to both conditions and actions. Notice that now we have state, we can do programming. Providing the action language is rich enough we can say set state to S at the end of the action, which when combined with a suitable condition amounts to ‘goto S’. Provided whatever or whoever has put the necessary work into the rules table, our system can do more or less anything.
All of which makes splitting and merging intervals more complicated that it was before. What are the properties of the modified or new intervals? We might impose a rule that said if the colour was null, then the interval as a whole was null.
Actions, as suggested above, all have the generic form ‘if A then B’, where A is a condition using any or all of the five bytes of each of intervals involved, that is to say either a single interval or a pair of intervals. The conditions would be able to distinguish left hand data from right hand data.
Again as suggested above, actions can only address the subject interval and the present thought is that we will not allow the action at a distance which computers manage. Instructions like, when sitting at location A, ‘add 16 to the contents of B’, where A and B might be at opposite ends of the computer, or at least of the chip. We want to maintain the possibility of biological implementation. But payload could be carried from one place to another, at least from one interval to another interval, identified by a character identifier rather than by position – a character identifier which may well be carried by more than one interval.
So, turning to back to Figure 13 above, we still have a fairly decentralised system, with the only two central components top right. The jiggler to make a preliminary selection and the external executor to activate the selected candidates by an appropriate setting of execution status. The internal executor can then take over, scanning its action table to see if there is any action to perform.
With control being returned to the external executor afterwards so that it can merge adjacent intervals with the same colour, adjusting display length appropriately and doing something about the other bytes of data, that is to say the colour, the code, the state and the payload.
The system starts with a starting tape of intervals. It then just carries on. It might get to a point where there is no more action. It might reach a stop action.
We believe a system of this sort would start to exhibit interesting behaviour. A system which would not be difficult to model in something like, for example, Microsoft’s Excel and no doubt Wolfram’s Mathematica would do even better – but this we have not yet attempted modelling with either of them. Not difficult but probably tedious in that a lot of code and data would need to be created for a lot of test runs – out of which something interesting might emerge.
This computing system is very much one dimensional, helped along by the trivial definition of a connected blob in one dimension. We have a set-up not so far from that of the cellular automaton. And while it may well be possible to generalised the foregoing to two dimensions, we have yet to work through exactly how that might work. If indeed it does.
Our present interest lies more in how the objects – both simple and complex objects – might interact with each other.
Some examples of moves of objects in one dimension
We are not here interested in rigid movement of the whole structure along the real line. We are only interested in uniform contractions or expansions to the extent that pixelation fails – for which see Figure 6 of reference 1. In what follows we are more interested in changes which affect the relations between the parts.
 |
| Figure 25 |
Mostly from the top down, in each panel. So in move 1 above, the green interval shrinks with a new null interval taking up the slack. We might well allow this move to work in both directions, with the green expanding to take the space of the null – something which might require energy. In move 2, the red interval first splits off a bit of neutral brown, which last is then absorbed by the green interval. In move 3, we simply switch a pair of intervals, a pair of simple objects. Only allowed when the intervals are small. While simple switching of potentially much larger complex objects seems much less plausible. In move 4 we take move 1 to the limit, replacing the green interval with the null interval. Complicated in move 5 by the external executor tidying up the new interval once the internal executor has finished. In move 6, a large green interval splits into two small intervals, separated by a null interval – a loss to the non-null interval total which may require energy to reinstate.
Note that being pedantic about the basic actions and about the need for adjacent intervals to be of different colour, often means that we need more than one such action to achieve the desired result; actions which may need to be coordinated using state.
But the sort of move we are particularly interested in is one object moving inside another and then, possibly, passing out the other side. How is this to be achieved while more or less preserving the integrity of the complex objects concerned?
 |
| Figure 26 |
Here we want to swap the green interval left with the red interval right – with the catch that they are both too big to swap entire. So we have to break off bits small enough that they may swap. Then the first move is to break off a small piece from both green and red. In the second move, the small green swaps with the small red and another small read breaks off the large red. In the third, the left hand small red merges with its null neighbour and the small green swaps positions with its null neighbour – it can’t grow or it won’t be able to swap. In the fourth, the left hand red again merges with its null neighbour; the small green swaps with the small red; and, another small red breaks off the right hand red. After the move, the external executor merges the two left hand reds. In the fifth, the green swaps with its null neighbour. In the sixth, the left hand red merges with its null neighbour. Red and green swap. Another bit breaks off the right hand fed. And the seventh is pretty much a repeat of the fifth. All rather tedious and long winded. We end up with a small chunk of green having got across the red interval. Then we tackle the next chunk of green. We might all several chunks of green to be on the go at once. Lots of possibilities.
We suggest that such a swap can be executed in a biologically plausible way. But is it worth the candle?
Additional information
We note that the core of the famous Turing machine is a one dimensional tape. To which to get full blown computing, at least in theory, is added a very modest amount of machinery and logic. Which does, however, include some registers to keep some global state, which our world of intervals does not allow, and for which see reference 2. Note that at least some Turing machines can quite easily be expressed as cellular automata, for which see reference 3.
 |
| Figure 27 |
We mentioned the weakness created by making holes in the boundary of a two dimensional blob. This weakness can be mitigated, with the help of a few neurons to manage things, by having double doors, rather in the way of a an airlock in a space ship, the gatehouse of a castle or the gates of a canal. Or, for that matter, an ion gate in the membrane of a cell, diagrams of which are very reminiscent of the castle above.
The attention of large animals, including humans, is very easily caught by anything that could possibly be another animal. Particularly anything that could be a pair of eyes. And such large animals are very sensitive to what those eyes are attending to: is that tiger looking at me with a view to lunch? Is that person looking at me? One result of all of which is the phenomenon described at reference 7. This sensitivity of the senses to animate – or animated – subject matter has found no place in the foregoing.
Conclusions
 |
| Figure 28 |
Our objective has been to look at what can be done in a one dimensional world. Could it be an alternative to the two dimensional world of LWS-R of reference 5?
We started with its massive limitations from a structural point of view, even when viewed from the outside. All kinds of stuff which works in two or three dimensions but which does not work in one. Life in one dimension is fairly limited.
Then there were the limitation of a one dimensional view of a three dimensional world, which had none of the expressivity of Figure 6 (the zebra), Figure 9 (the lower grade blobs) or Figure 28 (the higher grade blobs) above. That said, there are images that work well in one dimension and change over time of a simple one dimensional image is much easier to visualise than such change in two, let alone three, dimensions. Order works well in one dimensions, not so well in higher dimensions.
We went on to put some structure on sequences of intervals on the real line, on our segments. Structure which started off mainly in the eye of the beholder, rather than as something more substantial, more intrinsic. Structures which can become interesting when one animates them and looks at their behaviour over time, rather in the way of a cellular automaton.
We find that one can make complicated machines out of one dimensional structures, but machines which one can no longer visualise in a helpful way. We have yet to work out whether these machines would generalise to the world, for example, of Figure 28 above.
On balance, we remain of the belief that projecting a two dimensional view of the world into consciousness is worth all the extra expense. While noting that one use of that two dimensional world might be to maintain a two dimensional image of music, with dimensions of frequency and time and taking intensity for value.
References
Reference 1: http://psmv4.blogspot.com/2021/01/layers-of-approximation.html.
Reference 2: https://en.wikipedia.org/wiki/Turing_machine.
Reference 3: A new kind of science – Stephen Wolfram – 2002.
Reference 4: https://en.wikipedia.org/wiki/Peano_axioms.
Reference 5: https://psmv4.blogspot.com/2020/09/an-updated-introduction-to-lws-r.html.
Reference 6: https://www.vectorstock.com/.
Reference 7: Painters centre one eye in portraits - Tyler, C. W. – 1998.
Reference 8: https://psmv4.blogspot.com/2021/03/relationship-cues-in-painting.html.
Reference 9: [next post/last post] https://psmv4.blogspot.com/2021/03/a-one-dimensional-structure-part-i.html.
Group search key: sre.
No comments:
Post a Comment