In this series, we’ve done a review of mathematical notation, with an eye on how each notation helps or hinders student learning. In the prior posts, we started to explore function notation, and played with variations.  I’m not done with that topic, but will interrupt that sequence for a post on scientific notation.

Let’s start with the following picture:

Each line in the picture represents a number, and one line is different from the next only in where the decimal point is placed.  Some of the digits are grayed out.  I’m using the grayed-out digits as a short hand for indicating equivalent ways of writing the same value.  The number in the top row, for example, is most commonly written as .03412 (at least in the United States; in some countries, writing the 0 before the decimal point is standard – there it would be written as 0.03412), but the common form is not the only one, the number .03412 can be written as .034120 or .0341200 or 0000.03412000 etc.  For our purposes here in this post, it is useful to think of the version with all the grayed-out stuff present as the “real” or the “full” version of the number, and think of the version without the grayed-out stuff as the “common” or “abbreviated” version of that same number.  It also works to think of the grayed-out digits as “invisible” digits of the number.

Looking at these “full” versions, it is accurate to say that one line differs from the next only in the placement of the decimal point.  Looking at the “common” versions, it is not quite accurate to say that.  From one line to the next, some of the grayed-out digits have to be made solid, or some of the invisible digits have to be made visible.  In general, all digits between the left-most non-zero digit and the right-most non-zero digit need to be visible in the standard notation, as well as all the zeros between the decimal point and the rest of the number.  In addition, in some countries, at least one digit needs to be shown to the left of the decimal point, and at least one digit needs to be shown to the right of the decimal point, though this does not hold true in the United States.

One way to introduce scientific notation is to think of a calculator with a narrow display window.   For example, let’s assume, for example’s sake, that the window can only show 5 digits.

In these 5 digits, only the following rows of the picture above could be represented directly:

.03412
.3412
3.412
34.12
341.2
3412
34120

Calculators that can handle scientific notation are able to represent both larger and smaller numbers in the same 5-digit width, by using an additional symbol, usually “E”, and this “E” symbol is followed by one or more digits.

In the picture above, the numbers on the right are as before; on the left we’ve shown the corresponding number in scientific notation.  Note that all the numbers on the left fit in the 5 digits our hypothetical window of the calculator is capable of showing us.  Let’s look at the number on the left in the last row.  Here is one way to read it: “The number I’m showing you (3.412) is not quite the real number, the real number is seven rows lower.”  And if you start from the highlighted number on the right, 3.412, and go down seven rows, you get 34120000.  Another way of saying this: “The number I’m showing you (3.412) is not quite the real number, the real number has the decimal point moved seven places to the right.”  The “E7″ construct tells you that the real decimal point is seven places to the right of where it is shown.  What the calculator is relying on is that the user can make the necessary adjustment easily and fill in the zeros appropriately.  If we now look at the number on the left in the top row, we can read this as follows: “The number I’m showing you (3.412) is not quite the real number, the real number has the decimal point moved 2 places to the left.”  The “E-2″ construct tells you that the real decimal point is two places to the left of where it is shown.  Again, the calculator relies on the user to make these adjustments.

Almost all real-life calculators will show a number in scientific notation only if the more familiar form doesn’t fit in the window.  This hybrid approach is more practically useful, but doesn’t look as regular:

I propose that in school settings, teachers freely use the scientific notation as introduced above, consistent with how almost all calculators show it.  The essence of this notation is not even that it is able to show very large numbers and very small numbers in a limited space – though that is clearly the motivation for it – but that it shows a number.  To see it as a number, all you need to do is accept the new symbol E as part of a number, just like the decimal point is part of a number, and just as commas can make a number more easily scanned, (as in 3,000,000 for three million) – it still is just a number.

In contrast, the way scientific notation is often introduced in school textbooks is as an expression: instead of the calculator’s way of showing 3.412E7, the textbook will show .  It is true, of course, that when you evaluate this expression you will end up with the same result of 34120000 (or 34,120,000).   For students seeing this for the first time, this is unnecessarily confusing.  I’ve seen plenty of kids take to their calculator to turn this expression into a single number!  (Which, of course, usually doesn’t work in the sense that the calculator will not show the usual form of the result, but give it back in the 3.412E7 format.)  And the reverse, to take a number like 34,120,000 and be told to write it as makes even less sense for the students – they already got the answer, why would they want to turn it back into an expression that then needs to be calculated?  Many of these students never get that the scientific notation is an alternative way to write the number, and that it was never intended to treat it as an expression to be calculated.  In my experience, most of these same students don’t have the same confusion with the calculator format.  Since the calculator format (also used in any number of computer languages) is in no way inferior to the standard textbook format, it can be used throughout the classroom.  The teacher can simply note that there are people who were taught to write and that it is useful to be aware of this standard, but that it amounts to an old way of writing 3.412E7.  This statement is one that students can check on their calculator, if they so choose.

This repetitive nature of a number line bent around a slinky might also remind us of the scenario we looked at in the very first post of this series: there we looked at a mysterious machine with a “next” button and a window in which a number shows.  Each time we hit the button, another number shows in the window, in what seems to be a predictable repetition of the digits 3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,…   With the perspective of the recent posts, we can now think of a number line bent like a slinky – completing a full turn every ten numbers.  The mysterious box may move us along the number line on the slinky and show on the display where in the cycle we are.

The notion of things repeating after ten steps is of course central to our decimal number system.  It applies most literally to the right-most digit in a number, as we count up.  Let’s assume we start with the number 966839, as on the mechanical counter below, and then repeatedly count up by one.

We would produce the following sequence of numbers: 966839, 966840, 966841, 966842, 966843, 966844, 966845, 966846, 966847, 966848, 966849, 966850, 966851, 966852, 966853, …  When you only pay attention to the right-most digit, you see them repeat in a cycle of ten steps.  But the other digits in the number each cycle through a set of ten values in turn.  It just happens a lot slower.  If you take the same set of numbers, and look at the second digit from the right, you would see the sequence 3, 4…4, 5…5, etc., where each digit sticks around for ten steps and then changes to its next value.  In the mechanical counter, this is realized by having each digit position consist of an identical wheel (ten digit values in the same sequence), and kicking each wheel forward only when the wheel to the right of it transitions from a “9″ to a “0″.  The effect of this arrangement is that the wheels to the left rotate at a much slower rate than those on the right.  By putting enough wheels together in this arrangement, we can achieve very large cycles; in the mechanical counter shown, the overall cycle is one million.  This means that one million kicks of the right-most wheel will bring the whole counter back to its previous state, after which the whole thing repeats.

The rightmost wheel corresponds to the rightmost digit of the number.  If I have two numbers, and I focus exclusively on the rightmost digits, I can predict what the rightmost digit of the sum will be.  Also what the rightmost digit of the difference will be, and the rightmost digit of the product.  E.g. if I have a number X7 and another Y8, where the X and Y represent the digits that are covered up, you can predict that the sum will look like  Z5, and that the difference of X7 – Y8 will havea rightmost digit of 9, and the product X7 × Y8 will end in a 6.  Unfortunately, you can’t predict with certainty what the rightmost digit of the quotient is, even if there is no remainder.  This turns out to have something to do with 10 not being a prime number.

If it seems obvious to you that the rightmost digits of the sum and product only depend on the rightmost digits of the original numbers, please note that you cannot predict the next digit over quite so easily.  The second digit from the right of the sum does not depend only on the second digits from the right of the addends, and the second digit from the right of the product does not depend only on the second digits from the right of the factors.  However, it turns out that you can predict the final two digits of the sum and product by knowing only the final two digits of the addends or factors.  If our gear machine had wheels that had a hundred entries on them instead of ten, marked from “00″ to “99″, we could again say that the position of the final wheel of the product could be determined from the position of the final wheels of the factors.

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.

In this post I want to get started on playing with what’s known as modulo arithmetic, also called modular arithmetic, from our framework of operators and equivalence classes and properties.

As a starting point, let’s take another look at the number line.  In this older post, I suggest that this one thing, the number line, takes on a different character as students progress from using it for counting to – much later – locate numbers like π and √3 on it.  When we are just counting, the fact that the numbers on the number line are carefully spaced is not critical – but what is important is that the mark for 4 comes after the mark for 3 and the mark for 5 comes after the mark for 4, etc.  The number line is usually drawn as a straight line, but this may only be critical once we start to use number lines as axes on graphs.

The measuring tapes shown above, whether in inches or centimeters, are essentially number lines also, though they aren’t necessarily straight lines.  If you measure things with them, you probably want to stretch them out to be straight – but if you want to use them for many of the functions you use a number line for, it may be quite sufficient to unroll the tape enough so you can see the numbers you care about.

You could even take a slinky and turn it into a number line.

To do so, you would have to put markings along the rim.  Though the slinky would never be suitable for measuring like a measuring tape, it might serve quite well as a number line.

A sketch of one possible such number line is shown below:

The numbers 1-7 are shown; the slinky extends in both directions, as indicated by dotted lines.  Numbers are shown evenly spaced – in this particular example, precisely 4 whole numbers are placed along each circle.  For example, by the time we get to “5″, we are exactly where “1″ was, just slightly above it.

In prior posts, we’d look at a particular operation, and then decide on equivalence classes based on equal values of that operation, this time we’ll turn things around, and decide on the equivalence classes first.   Can we do this and get away with it?  Sure, if we cast it in terms of: “with respect to what operation(s) will these equivalence classes in fact be equivalent?”

On the slinky number line just sketched, we are going to consider the equivalence classes based on vertical alignment, like this:

Another way of talking about this equivalence is that we consider equivalent all numbers that are 4 apart.  The representatives of these equivalence classes, just like in our earlier posts, are found at the end points of the blue arrows.  So 1, 2, 3 and 4 are the representatives.  There is nothing magical about this particular choice, you can make a very good case for using 0, 1, 2 and 3 as the representatives instead.  We could also have picked -2, -1, 0 and 1.  In a sense, it is too early to argue which make for the best representatives – we haven’t looked at relevant operations yet.

In the next post, we’ll apply this particular equivalence structure to the operations of addition and subtraction.

x

In the last two posts, we saw equivalence classes as well as contour lines that connected elements that were equivalent to each other.  The contour lines could be followed till you arrived at a specially marked entry that serves as the representative of that equivalence class.  The process of finding the marked representative of an equivalence class is itself something we can think of as an operator, as something done in a black box.  How the box does this may not be of our concern; the box might follow contour lines as in our examples, or it may have other ways – better ways perhaps – of finding the representative element in the equivalence class.
Typically, operators that find the representative member of an equivalence class are not invertible.  That is, many different elements can lead to the same representative member, and from the representative member alone, you can’t recover which of the elements led to it.
A complication with finding the representative member of an equivalence class is that there is some uncertainty about which element is the representative member.  Strictly speaking, there is nothing about the equivalence that shouts out which member is the representative member, it relies on an outside perspective.  With respect to one property, all elements in the equivalence class are the same – that’s how they get to be members in the equivalence class in the first place.  Yet with respect to some other property, one element of the equivalence class stands out and is marked and thus becomes the representative.  It’s time for an example to make this explicit.

The example we’ll play with in this post deals with fractions.  Just like the previous posts dealt with addition and multiplication, this time we will deal with division, but in a particular sense.  We’re not interested in divisions carried out using decimals, we will write the result like a fraction.  The following table shows this:

The table on top shows each of the fractions you can get when the numerator is between one and ten, and when the denominator is also between one and ten.  For fractions, there is an already existing notion of equivalence: equivalent fractions.  (If you are not familiar with that, just think of fractions as equivalent when both give the same decimal number when treated as a division on your calculator.  For example, 2/3works out to .6666… on your calculator when you divide 2 by 3, and so does 4/6 when you divide 4 by 6 on your calculator – thus they are regarded as equivalent fractions.)

In the table on the bottom, some of these equivalencies are shown.  All fractions equivalent to 1/2 are replaced by a contour line that connects them to 1/2.  The fractions 2/4, 3/6, 4/8 and 5/10 are so connected.  Turns out, these equivalent fractions form a straight line, and this line, when extended, goes through a point in the top left corner.  There are more equivalent fractions in the table than are shown, but I left them out to keep the main ideas visible.  The last (closest) fraction on the blue line towards the top left is marked in a special color, and is chosen to be the representative of the equivalence class of equivalent fractions.  These correspond to what are called reduced fractions or simplified fractions in school.  In school, reducing fractions often seems like a chore, and its purpose hidden in the mumbling and mist of “they are simpler”.  Later in school, you are asked to find a different kind of representative of the equivalence class: a fraction, equivalent to the one you start with, that has a denominator of exactly 100.  These are called percentages.  In the world of percentages, divisions where the denominator is 100 are more equal than others.

In the next post, we’ll look at equivalent subtractions.

Below, I show three examples of operators with two numbers as input, and with a single output, and yet no information is lost between input and output.

All these examples take two individual numbers as input, and produce a single output, which is the pair of numbers that were present on the input.  This is more than merely a semantic trick – in school math you see it used most often for coordinate pairs, and you can see it in fractions even if most people don’t think of fractions as a special kind of pair.  In the third example, we turn the individual inputs into a vector, using the notation we’ve played with at length in our series on vectors, e.g. in this post about shopping list and price lists.  In school math, the notation typically used for vectors is closer to that shown in the left example.

Mathematicians tend to use the phrase “ordered pair” for all three of these examples.  A standard notation for an ordered pair is the one shown on the left: the numbers, separated by a comma, enclosed in parentheses.  This notation is a fairly useful one, though perhaps a bit overused.

These various pairing operators are all invertible - that is, you could reconstruct the inputs from knowing the output.  It is interesting that most of the operations we’re familiar with from elementary school mathematics (addition, subtraction, etc) are not invertible in this sense.  Knowing the sum does not allow you to uniquely reconstruct what the numbers were that led to that sum.

In this post, I’d like to take another look at counting.  Counting was discussed earlier in this post.  We saw that counting means different things at different degrees of sophistication, starting with producing a sequence of counting numbers “one, two, three”  like a song similar to “a, b, c, d, e, f, g” to the melody of “Twinkle, twinkle, little star”.  For the purposes of this post, I’m interested in counting as the process by which we obtain the number of blocks in a pile of (identical) blocks.  Even more specifically, I’m going to be looking at counting a set of objects that are fixed in place and arranged linearly, as shown below:

Several stages of the counting process are shown, one below the other.  Each row shows the group of green blocks to be counted.  How far the green blocks extend towards the right we don’t know, because our view of them is blocked, for the moment, in our current position.  To visualize the process of counting, we imagine the progress being marked by a separator (the dotted vertical line) that we gradually move from left to right.  As the separator moves from the left of a block to the right of that block, the count (shown on the left of each row) is increased by one.

A key idea associated with counting is this separation of the whole pile into two groups: the group of stuff that has already been counted, and the group of stuff that is yet to be counted.  A key operation associated with counting is the moving of the separator, which has the effect of moving one of the blocks from the group of yet to be counted into the group of stuff that that has been counted.  This move, repeated until the pile of uncounted stuff is empty, is associated with the increase of the number.  Normally, it is the speaking of the increasing numbers that we call counting – yet unless the speaking of the increasing numbers occurs in lockstep with the action of moving the separator over, we would arrive at a meaningless number.

The same “moving over the separator” operation shows up in a related scenario, but one where the total count is already known.  Imagine a group of 15 students giving one-minute presentations one at a time.  At any moment during this affair, there is a group of students who haven’t yet given their presentations, a group of students who has, and at most one student who is in the middle of giving the presentation.  If we took snapshots right after a student completed a presentation, the series of snapshots might resemble the picture above quite closely.  Here is a representation of it:

Here, the students who have completed their presentation are on the left, those who haven’t yet are on the right, and the separator marks the split between the two groups.  As the student on the right of the split finishes the presentation the separator moves over one place.   Unlike the counting example, here we already know the total, we know how many students are going to be giving the presentation.  Here we can keep track of two numbers, the number of students on the left who have done their presentation, and the number of students on the right who haven’t.  As each presentation finishes, the separator moves to the right, the number on the left increases and the number on the right decreases, all in lockstep.

I think it is interesting to show an operator that matches this movement of the separator.  Above on the left, I’ve indicated how such an operator might be drawn – you see it has two inputs and two outputs.  If you don’t like multiple outputs, you may prefer the version on the right, which has a single object as its output, an object we might call a “split”.  If 2|13 is a split of 15, then “moving the separator” produces a different split of 15, namely 3|12.

You may have wondered why we wouldn’t just do the following:

and the short answer to that would be: yes, we could.  But the longer answer is more interesting, I think.  One of the most interesting things about moving the separator is that it really is just a single action: in one single movement, one of the sides gets bigger and the other side gets smaller by the same amount.   There are many, many real-life situations where this issue is critical.  I already discussed some of this in a post about transactions: no industrial-strength database could function without it.   When you get money from an ATM, you would not accept your account being dinged for the $100 you withdraw without actually getting the cash in your hands, and the bank would hate to give you the $100 in cash without also decreasing the balance in your account.  For you, as well as for the bank, the two sides of the exchange must happen as one, even if a power failure hits the bank at the worst possible moment.

And yet, in many ways the combination of the “add 1″ and the “subtract 1″ operators does in fact produce the same result as the “move the split by one” operator – they are almost equivalent.  Basically, we should take seriously the box drawn in dotted lines above, and give it a serious job.  The job we want it do is to guarantee that what’s happening inside of it happens as a single whole, indivisibly.  How it does this, we don’t care, but we don’t ever want to see the addition done without the corresponding subtraction being finished also, nor do we want to see the subtraction done without the corresponding addition being finished also.  It is possible to think of this issue in terms of synchronization; and it is worth noting that so far in this series we’ve been ignoring pretty much all issues of time, speed, delay and synchronization in connecting inputs to outputs.

x

The arithmetic operations from elementary school: add, subtract, multiply, divide – these are usually conceived as two-input, one-output operations.  There are some more you learn in secondary school: exponentiation, and perhaps the min and max operators we looked at in the previous post.  Interestingly, most of the new operations you learn in secondary school are single-input types: absolute value, square, square root; and later on sin, cos, tan and other trigonometric functions, and log.  Occasionally, secondary school students run into situations where there are more than two inputs (e.g. to find a slope of a line going through two given points) but these rarely rise to the level of standardized notation.

Even things like the quadratic formula, which looks for the value of for which , and where the numbers , and could be regarded as the inputs, is rarely seen or treated as an operator.  Instead, it is treated as a series of one-offs: here’s an equation, solve it.  Here’s another equation, solve it too.

There is a vocabulary to distinguish these kinds of operators and functions, though the vocabulary is more firmly established in computer science than it is in mathematics.  The one-in, one-out kind are called unary operators and unary functions; the two-in, one-out kind are called binary operators and binary functions.  Functions with three values coming in and one coming out would be called ternary functions, and so on.  Sometimes you see the notation “n-ary function” for a function that has n values coming in (for some unspecified n) and one value coming out.

Some mathematicians might scoff at all this, and bring up that in some sense, all operators and all functions are of the one-in, one-out type.  What comes in, no matter what it is, is called the domain, and what comes out, whatever it is, is called the range.  Neither domain and range have to be numbers.  They can be whatever they need to be.

For example, subtraction can be seen as a single-in, single-out function where the domain (what comes in) consists of pairs of numbers.  The range (what comes out) consists of single numbers.  The image below compares the way we normally think of subtraction, on the left, and subtraction as an operator on a pair of numbers, on the right.

Though the view on the right may seem artificial, it seems less so if you see what we have to do to the diagram on the left to keep straight what input is what.

As another example, sort-by-due-date can be seen as a single-in, single-out operator where the domain consists of a bag of bills and the range consists of a linear arrangement  of these same bills – a special arrangement where the bills that need to be paid soon are up front and the bills that need to be paid later are in the back.

In prior posts in this series, we’ve looked at state machines, where the operators operate on the state of the machine.   We’ve played with stopwatches and calculators as examples of such machines.  Sometimes the state of these machines consisted of a single number, but more commonly, the state consists of multiple numbers and other things.  For example, the state of the tab in your browser window includes a history of sites, so that the “back” operator has a way to get you back to the site you were before you clicked on a link.

In the next post, we’ll play with some operators that have interesting domains and interesting ranges.

In this post, I’d like to introduce and look at some fairly simple operators (operating on single numbers) that don’t look like arithmetic at all.

The first two act like filters.  The one on the left makes sure that the number coming out is at most 11.  Yet as long as the number going in is less than 11, it is passed through without modification.  The one on the right does a similar thing, but makes sure the number coming out is at least 3.

The symbols used here for each of these filters is intended to evoke the image of the graph of each of the functions.  I like the name lid for the operator on the left, and bottom for the name of the operator on the right.

Here is the graph for our lid function:

and here is the graph for our bottom function:

As simple as these operators may seem, if you try to find operators or functions with these descriptions on the internet, you may be surprised.  In these forms, they are not in widespread use.   Historically, there are two other functions that are in widespread use, min and max, and our bottom and lid functions turn out to be special cases of the min and max functions.  In case you’re not familiar with min and max, min stands for minimum and max stands for maximum.  The minimum of a set of numbers is the smallest of them, and the maximum of a set of number is the largest of them.

The picture above shows a min operator and a max operator, each taking two numbers as input.  Below, you’ll see how these operators can be used to build the bottom and lid operators.

As before, we’ve given the min operator two inputs, and the same for the max operator.  However, one of these inputs is fixed.  The overall effect of a fixed input of 11 using the min operator is that the result can never get bigger than 11, after all if the input is bigger than 11, the min operator will select 11 as the minimum.  If the input to the min operator is less than 11, the min operator will select that input.  (Of course, if the input is exactly 11, the min operator will produce an output of 11, and it could do so by selecting either one of the inputs.)  Similarly, the output of the max operator with a fixed input of 3 will never drop below 3.

If you are like me, these results look backwards and counter-intuitive.  It seems strange to me, at first glance, that the min operator will produce an output that is at most 11, or that the max operator will produce an output that is never below 3.  And yet, they do work as advertised.

So, do we need the bottom and lid operators if we already have the widely-known and accepted min and max operators?  Certainly, the world has survived well without these.  A full answer would have to address both the cost of introducing new notation and terminology, as well as the cost of any confusion when using the min and max operators in the configurations as shown above.

and not only does it produce perfect square numbers, one after another, as the “next” button is pressed, it produces pairs of counter and square (I’m deliberately ignoring the difference component here).  So after a number of “next” presses, we might see

and a little while later

and it might occur to us that if we wanted to find the square of 37, we could hit “start” and then press “next” till the counter showed 37.  This gives us one particularly way of computing the square of 37.  Now, this may not be your favorite way, and it may not be the most efficient way.   And when it comes to computing squares, there are lots of other ways as well.

Yet the idea of generating pairs of values (here counter and square) until one comes by that has the right value for counter, and then looking at the matching square value - this is a general idea that has lots of practically useful applications.  It also allows us a broader take on what a function is.   A number goes in: “37″, and a number comes out. Though it involves operators, it does so in a rather involved way, with twists and turns.  Still – the process is reproducible.  Do the same sequence again, and the same number will come out.

The state machine of the kind we’ve shown here gets us close to the essence of what are known as primitive recursive functions.