In this series, we’ve pictured *operators *as black boxes with inputs and outputs. In the previous post we looked at rather ordinary addition from a less ordinary perspective: we imagined the number line arranged as a cylindrical spiral, like a slinky. We imagined that numbers four apart would end up vertically aligned, with one above the other.

We’ll be looking at a variation of that in the current post, and our vehicle for introducing this will be an old-fashioned alarm clock:

We may be getting close to an era where children won’t have any idea how to read time on a clock like this, never even having seen one in grandma’s house. The saying “Even a broken clock shows the correct time twice a day” will not make any sense to them either. If a digital clock somehow got stuck and showed a single static display, we’d still expect it to show whether it was AM or PM, we would expect it to show the date, we might expect it to show the day of the week. Even without the day of the week, such a clock would show the correct time only once a year.

The hour pointer (“Mickey’s little hand” for those from the right country and the right era) in the picture is pointing at the “1”, and exactly one hour later, it will be pointing at the “2”. Each hour it advances one number around the clock face, and it keeps doing so: one hour after it is pointing to the “12”, it will point at the “1” again. So if we focus only on the hour hand, and ignore anything else about this clock, we would expect to see behavior that strictly repeats every 12 hours.

The picture above symbolizes the “advance one hour” or “one hour later” effect on the position of the hour hand. So if the input of the box s “11”, the output will be “12”, if the input of the box is “12”, the output will be “1”. This is shown below in table form:

Now please look at the diagram below:

The top row of this diagram shows the repeated application of the “one hour later” operator. The input on the far left will be a clock time (whole hours only), and as we move rightwards through the boxes, we trace the time on the clock going forward one hour per box. The bottom row is a simple counter, starting at zero and going up by one each time. What’s different from what we’ve done before: the intention is that the two run together: at one point, both machines would be at A, and some time later, both would be at B – they stay in synch. There are other ways to model the synchronization of different parts of a machine, and we’ve done so earlier in this series.

At A, the bottom machine shows an output of 1, and the top machine shows the time one hour later than the input time. At B, the bottom machine shows an output of , and the top machine shows the time two hours later than the input time. Similarly, at the very right of the diagram shown above, the output of the top row will show the time 14 hours later than the input time, and the output of the bottom row will simply show 14.

In the diagram above, we show the same idea, two machines running in synch, one tracking the hours on the clock face, the bottom one counting the hours gone by. We no longer assume the bottom row starts with zero. Note that this time we’ve shown exactly 12 stages. For the bottom row, looking at the net effect of running 12 stages – of adding 1 in each stage – is easy. The next effect is adding 12 to the incoming cont. For the top row, the net effect of running 12 stages – of advancing the clock face one hour in each stage – isn’t that hard either: regardless of the position on the clock face when we start, after 12 stages we will have made a full cycle around the clock face, and we will have returned exactly to the point where we started. We can show this as follows:

The top box is what we’ve called* *an *empty box *or an* identity operator *in earlier posts. One of the implications of this is that if we a long train of the “one hour later” operators, we can take any sequence of 12 consecutive “one hour later” operators, and remove it from the train without altering the net effect of the train.

So if we had a machine with 38 stages, with each stage a pair of “one hour later” on top and an ordinary +1 on the bottom, we could find 12 consecutive stages and reduce them as above, and repeat this process till we were left with:

From the bottom row we can confirm that there were indeed 38 stages (the net effect of the bottom row is +38); from the top row it is clear that the net effect is two stages’ worth of “one hour later” (i.e. two hours later).

In terms of their effect on the clock face, 38 stages and 2 stages are equivalent. The standard language for that is that 38 and 2 are equivalent *modulo 12*.

We will look further into this in subsequent posts.

Pingback: Operators, Functions, and Properties – part 42 « Learning and Unlearning Math