In this series, we’ve been looking at simple machines where pushing a button invokes an operator that changes the state of the machine. Stopwatches, coffee makers, calculators are all examples of such machines – some simpler than others. Many of the operators we’ve encountered are operators that work on a single number going in, and produce a single number coming out. By stringing together these kinds of operators, we can get rich and surprising behavior.

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.